Some info about us....
Check out similar work by others!
| Name of Project | Description | Link |
|---|---|---|
| LittleFe | Educational microcluster that comes with the BCCD and educational modules. | http://littlefe.net/ |
| BCCD | Bootable cluster CD project includes all the software needed to play in a cluster environment. The LittleFe project uses this software environment. | http://bccd.net |
Box 1
Box 2
Box 3
Box 4
Box 5
Box 6
Box 7
Box 8
Box 9
Box 10
Box 11
Box 12
This work is supported by SIGCSE Special Grants program, LittleFe Buildout program at SIGCSE 2013, and the local compute and human resources at University of Wisconsin-La Crosse.


×
HOME
ABOUT
AMENITIES
BOOK
CONTACT
☰
TIME
7:00AM
8:00AM
9:00AM
10:00AM
11:00AM
12:00PM
1:00PM
2:00PM
3:00PM
4:00PM
5:00PM
DATE
Pick your date
November, 2018
reset


BY CLICKING THE ACCEPT BUTTON BELOW I CONSENT FOR ZEST AND IT S PARTNERS AND AUTHORIZED TESTERS TO PERFORM THE TEST I AM ABOUT TO RECEIVE AND TO USE AND DISCLOSE MY PROTECTED HEALTH INFORMATION AS FOLLOWS.
With my consent, Zest, LLC and its partners and authorized testers may use and disclose protected health information about me to carry out treatment, payment and healthcare operation. Please refer to Zest notice of privacy practices for more complete description of such use and disclosures.
I have the right to review and acknowledge that I have reviewed the notice of privacy practices prior to signing this consent. Zest reserves the right to revise its notice of privacy practices at any time.
With my consent, Zest and its partners and authorized testers may email, text or mail to my address or call any other designated locations any items that assist the practice in carrying out treatment, payments and operations. This includes, but is not limited to: appointment reminders, emailing correspondence, test results, medical records, faxing records and insurance items pertaining to my clinical care, as long as they are marked personal and conﬁdential.
With my consent to Zest MedcoI have the right to restrict how my information is used or disclosed. However, the practice is not required to agree to my request. If the practice does agree to my request, it is bound by these agreements.
By clicking the accept button for this form I am consenting to Zest, their partners and authorized testers the use and disclosure of my protected healthcare information. I may revoke my consent in writing except to the extent that the practice has already made disclosures in reliance upon my prior consent. If I do not sign this consent, Zest, their partners and authorized testers may decline to provide treatment to me.
Payment for rendered services during your appointment is due on the date of service. Zest, their partners and authorized testers is not contracted with insurance policies. Therefore, all insurance policies will not cover the cost of services rendered by Zest, their partners and authorized testers unless otherwise stated in writing. It is the patient's responsibility to have an understanding of their particular insurance policy's beneﬁts and coverage. The patient's ﬁnancial obligation as an INSURED patient on the date of service is:
Receiving your results
You may login at https://app.zest.com to view your results.
Enter your username and password. If you do not have one then click the reset password link below the login and follow the instructions. All results will be reported via text or email notice through our HIPAA compliant Zest Portal Site.


Check out this selection of products at a discounted price.
This is a short product description.
Availability: In Stock
Rating:


Who Are We.
Next is an efficient and talented team of designers
and developers of information.
We design web sites, digital campaigns, interactive applications, management tools of contents
that help to build strong and sustainable relations with customers.
Next is an efficient and talented team of designers
and developers of information.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
We have a range capabilities in the technologies we are working
with delivring the best projects for our clients.
A passionate group of professionals that come from every corner
of the globe each bringing their own expertise
We have a specific ordering of work activities across time
with a beginning and an end and defined outputs.


bootstrap(configure: Function): Promise
Manually bootstraps an application.
Parameters
configure: Function
A callback which passes an Aurelia instance to the developer to manually configure and start up the app.
Returns
A Promise that completes when configuration is done.


Not complete.
Partial differentiation is when a function of two or more variables is differentiated with respect to just one of them.


Department of Student Welfare
(DSW-DAVV)
Department of Student Welfare
(DSW-DAVV)
HOME
ABOUT US
Vision & Mission
Chancellor
Chancellor Message
Vice Chancellor
Student Welfare Activities
RESOURCES
Forms
Scholarship
Schemes
Notices
Hostel
YOUTH FESTIVAL
ANTI-RAGGING
ACHIEVEMENTS
GALLERY
CONTACT US
DAVV
Hon'ble Vice-Chancellor
Dr. Renu Jain
Vice-Chancellor
Contact Us
Department of Student Welfare
Nalanda Campus, R. N. T., Rabindranath Tagore Marg, Chhoti Gwaltoli, Indore, Madhya Pradesh, Pin-452001
0731 - 2524863
Quick Links
Home
Notices
DAVV
About Developers


Cookie persistence and is enabled here.
(Also, double-click handler expands document nodes.)
Select a node and hit [F5] to refresh, to see how the active node and
expansion and selection states are restored.
NOTE: if this doesn't seem to work, it's probably because the frame
content is cached by the browser.
Try this example as an
unframed page.
jquery.dynatree.js project home Link to this page Example Browser View source code


rss feed recommendations
organized by topic
nyc
-
Greenpointers: greenpoint news
-
EV Grieve: east village news
-
Eating in Translation: nyc food events
-
The Lo-Down: lower east side news
-
Eater NY: nyc food news
-
Time Out New York: nyc events
tech
-
Chris Coyier: web dev/personal blog
-
Jake Archibald: web dev
-
Smashing Magazine: web dev
-
CSS Tricks: web dev
-
Hacker News: interesting links mostly about tech
culture + art
-
Colossal: art
-
Sabukaru: japanese culture
-
The Walrus : interesting articles from canada
-
Kottke: interesting links
-
Home Designing: interior design ideas
funny stuff
-
Reductress: feminist satire
-
Clickhole: satire
-
Hard Drive: video game news/satire
-
The Onion: satire
recipies
-
Just One Cookbook: japanese recipes + culture
-
Isabel Eats: mexican recipies
-
A Cozy Kitchen: recipies
-
Budget Bytes: easy + cheap recipies
misc
-
Maxis Match CC World: maxis match sims 4 custom content


Note that by default, logging back in with Azure AD will happen automatically if your browser stores session information. This is a simulated "logged out" page.


SLAMon Status
Known agents
Tasks
Add a task
task_id
test_id
task_type
task_version
task_data
{}
Send


My Site
29
Error establishing a database connection
Database Update Required
The database update process may take a wee while, so you can waste time.
Update Site Database


1 : /*
2 : * jccoefct.c
3 : *
4 : * Copyright (C) 1994-1997, Thomas G. Lane.
5 : * This file is part of the Independent JPEG Group's software.
6 : * For conditions of distribution and use, see the accompanying README file.
7 : *
8 : * This file contains the coefficient buffer controller for compression.
9 : * This controller is the top level of the JPEG compressor proper.
10 : * The coefficient buffer lies between forward-DCT and entropy encoding steps.
11 : */
12 :
13 : #define JPEG_INTERNALS
14 : #include "jinclude.h"
15 : #include "jpeglib.h"
16 :
17 :
18 : /* We use a full-image coefficient buffer when doing Huffman optimization,
19 : * and also for writing multiple-scan JPEG files. In all cases, the DCT
20 : * step is run during the first pass, and subsequent passes need only read
21 : * the buffered coefficients.
22 : */
23 : #ifdef ENTROPY_OPT_SUPPORTED
24 : #define FULL_COEF_BUFFER_SUPPORTED
25 : #else
26 : #ifdef C_MULTISCAN_FILES_SUPPORTED
27 : #define FULL_COEF_BUFFER_SUPPORTED
28 : #endif
29 : #endif
30 :
31 :
32 : /* Private buffer controller object */
33 :
34 : typedef struct {
35 : struct jpeg_c_coef_controller pub; /* public fields */
36 :
37 : JDIMENSION iMCU_row_num; /* iMCU row # within image */
38 : JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
39 : int MCU_vert_offset; /* counts MCU rows within iMCU row */
40 : int MCU_rows_per_iMCU_row; /* number of such rows needed */
41 :
42 : /* For single-pass compression, it's sufficient to buffer just one MCU
43 : * (although this may prove a bit slow in practice). We allocate a
44 : * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
45 : * MCU constructed and sent. (On 80x86, the workspace is FAR even though
46 : * it's not really very big; this is to keep the module interfaces unchanged
47 : * when a large coefficient buffer is necessary.)
48 : * In multi-pass modes, this array points to the current MCU's blocks
49 : * within the virtual arrays.
50 : */
51 : JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
52 :
53 : /* In multi-pass modes, we need a virtual block array for each component. */
54 : jvirt_barray_ptr whole_image[MAX_COMPONENTS];
55 : } my_coef_controller;
56 :
57 : typedef my_coef_controller * my_coef_ptr;
58 :
59 :
60 : /* Forward declarations */
61 : METHODDEF(boolean) compress_data
62 : JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
63 : #ifdef FULL_COEF_BUFFER_SUPPORTED
64 : METHODDEF(boolean) compress_first_pass
65 : JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
66 : METHODDEF(boolean) compress_output
67 : JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
68 : #endif
69 :
70 :
71 : LOCAL(void)
72 28985: start_iMCU_row (j_compress_ptr cinfo)
73 : /* Reset within-iMCU-row counters for a new row */
74 : {
75 28985: my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
76 :
77 : /* In an interleaved scan, an MCU row is the same as an iMCU row.
78 : * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
79 : * But at the bottom of the image, process only what's left.
80 : */
25181: branch 0 taken
3804: branch 1 taken
81 28985: if (cinfo->comps_in_scan > 1) {
82 25181: coef->MCU_rows_per_iMCU_row = 1;
83 : } else {
2900: branch 0 taken
904: branch 1 taken
84 3804: if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
85 2900: coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
86 : else
87 904: coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
88 : }
89 :
90 28985: coef->mcu_ctr = 0;
91 28985: coef->MCU_vert_offset = 0;
92 28985: }
93 :
94 :
95 : /*
96 : * Initialize for a processing pass.
97 : */
98 :
99 : METHODDEF(void)
100 4479: start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
101 : {
102 4479: my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
103 :
104 4479: coef->iMCU_row_num = 0;
105 4479: start_iMCU_row(cinfo);
106 :
4479: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
107 4479: switch (pass_mode) {
108 : case JBUF_PASS_THRU:
0: branch 0 not taken
4479: branch 1 taken
109 4479: if (coef->whole_image[0] != NULL)
110 0: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
111 4479: coef->pub.compress_data = compress_data;
112 4479: break;
113 : #ifdef FULL_COEF_BUFFER_SUPPORTED
114 : case JBUF_SAVE_AND_PASS:
0: branch 0 not taken
0: branch 1 not taken
115 0: if (coef->whole_image[0] == NULL)
116 0: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
117 0: coef->pub.compress_data = compress_first_pass;
118 0: break;
119 : case JBUF_CRANK_DEST:
0: branch 0 not taken
0: branch 1 not taken
120 0: if (coef->whole_image[0] == NULL)
121 0: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
122 0: coef->pub.compress_data = compress_output;
123 0: break;
124 : #endif
125 : default:
126 0: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
127 0: break;
128 : }
129 4479: }
130 :
131 :
132 : /*
133 : * Process some data in the single-pass case.
134 : * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
135 : * per call, ie, v_samp_factor block rows for each component in the image.
136 : * Returns TRUE if the iMCU row is completed, FALSE if suspended.
137 : *
138 : * NB: input_buf contains a plane for each component in image,
139 : * which we index according to the component's SOF position.
140 : */
141 :
142 : METHODDEF(boolean)
143 24506: compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
144 : {
145 24506: my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
146 : JDIMENSION MCU_col_num; /* index of current MCU within row */
147 24506: JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
148 24506: JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
149 : int blkn, bi, ci, yindex, yoffset, blockcnt;
150 : JDIMENSION ypos, xpos;
151 : jpeg_component_info *compptr;
152 :
153 : /* Loop to write as much as one whole iMCU row */
24506: branch 0 taken
24506: branch 1 taken
154 73518: for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
155 24506: yoffset++) {
36561: branch 0 taken
24506: branch 1 taken
156 85573: for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
157 36561: MCU_col_num++) {
158 : /* Determine where data comes from in input_buf and do the DCT thing.
159 : * Each call on forward_DCT processes a horizontal row of DCT blocks
160 : * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
161 : * sequentially. Dummy blocks at the right or bottom edge are filled in
162 : * specially. The data in them does not matter for image reconstruction,
163 : * so we fill them with values that will encode to the smallest amount of
164 : * data, viz: all zeroes in the AC entries, DC entries equal to previous
165 : * block's DC value. (Thanks to Thomas Kinsman for this idea.)
166 : */
167 36561: blkn = 0;
103899: branch 0 taken
36561: branch 1 taken
168 140460: for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
169 103899: compptr = cinfo->cur_comp_info[ci];
170 103899: blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
35891: branch 0 taken
68008: branch 1 taken
171 103899: : compptr->last_col_width;
172 103899: xpos = MCU_col_num * compptr->MCU_sample_width;
173 103899: ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
137568: branch 0 taken
103899: branch 1 taken
174 241467: for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
36541: branch 0 taken
101027: branch 1 taken
29814: branch 2 taken
6727: branch 3 taken
175 174109: if (coef->iMCU_row_num < last_iMCU_row ||
176 36541: yoffset+yindex < compptr->last_row_height) {
177 261682: (*cinfo->fdct->forward_DCT) (cinfo, compptr,
178 130841: input_buf[compptr->component_index],
179 : coef->MCU_buffer[blkn],
180 : ypos, xpos, (JDIMENSION) blockcnt);
16817: branch 0 taken
114024: branch 1 taken
181 261682: if (blockcnt < compptr->MCU_width) {
182 : /* Create some dummy blocks at the right edge of the image. */
183 16817: jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
184 16817: (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
16817: branch 0 taken
16817: branch 1 taken
185 33634: for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
186 16817: coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
187 : }
188 : }
189 : } else {
190 : /* Create a row of dummy blocks at the bottom of the image. */
191 6727: jzero_far((void FAR *) coef->MCU_buffer[blkn],
192 6727: compptr->MCU_width * SIZEOF(JBLOCK));
13454: branch 0 taken
6727: branch 1 taken
193 20181: for (bi = 0; bi < compptr->MCU_width; bi++) {
194 13454: coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
195 : }
196 : }
197 137568: blkn += compptr->MCU_width;
198 137568: ypos += DCTSIZE;
199 : }
200 : }
201 : /* Try to write the MCU. In event of a suspension failure, we will
202 : * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
203 : */
0: branch 1 not taken
36561: branch 2 taken
204 36561: if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
205 : /* Suspension forced; update state counters and exit */
206 0: coef->MCU_vert_offset = yoffset;
207 0: coef->mcu_ctr = MCU_col_num;
208 0: return FALSE;
209 : }
210 : }
211 : /* Completed an MCU row, but perhaps not an iMCU row */
212 24506: coef->mcu_ctr = 0;
213 : }
214 : /* Completed the iMCU row, advance counters for next one */
215 24506: coef->iMCU_row_num++;
216 24506: start_iMCU_row(cinfo);
217 24506: return TRUE;
218 : }
219 :
220 :
221 : #ifdef FULL_COEF_BUFFER_SUPPORTED
222 :
223 : /*
224 : * Process some data in the first pass of a multi-pass case.
225 : * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
226 : * per call, ie, v_samp_factor block rows for each component in the image.
227 : * This amount of data is read from the source buffer, DCT'd and quantized,
228 : * and saved into the virtual arrays. We also generate suitable dummy blocks
229 : * as needed at the right and lower edges. (The dummy blocks are constructed
230 : * in the virtual arrays, which have been padded appropriately.) This makes
231 : * it possible for subsequent passes not to worry about real vs. dummy blocks.
232 : *
233 : * We must also emit the data to the entropy encoder. This is conveniently
234 : * done by calling compress_output() after we've loaded the current strip
235 : * of the virtual arrays.
236 : *
237 : * NB: input_buf contains a plane for each component in image. All
238 : * components are DCT'd and loaded into the virtual arrays in this pass.
239 : * However, it may be that only a subset of the components are emitted to
240 : * the entropy encoder during this first pass; be careful about looking
241 : * at the scan-dependent variables (MCU dimensions, etc).
242 : */
243 :
244 : METHODDEF(boolean)
245 0: compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
246 : {
247 0: my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
248 0: JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
249 : JDIMENSION blocks_across, MCUs_across, MCUindex;
250 : int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
251 : JCOEF lastDC;
252 : jpeg_component_info *compptr;
253 : JBLOCKARRAY buffer;
254 : JBLOCKROW thisblockrow, lastblockrow;
255 :
0: branch 0 not taken
0: branch 1 not taken
256 0: for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
257 0: ci++, compptr++) {
258 : /* Align the virtual buffer for this component. */
259 0: buffer = (*cinfo->mem->access_virt_barray)
260 0: ((j_common_ptr) cinfo, coef->whole_image[ci],
261 0: coef->iMCU_row_num * compptr->v_samp_factor,
262 0: (JDIMENSION) compptr->v_samp_factor, TRUE);
263 : /* Count non-dummy DCT block rows in this iMCU row. */
0: branch 0 not taken
0: branch 1 not taken
264 0: if (coef->iMCU_row_num < last_iMCU_row)
265 0: block_rows = compptr->v_samp_factor;
266 : else {
267 : /* NB: can't use last_row_height here, since may not be set! */
268 0: block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
0: branch 0 not taken
0: branch 1 not taken
269 0: if (block_rows == 0) block_rows = compptr->v_samp_factor;
270 : }
271 0: blocks_across = compptr->width_in_blocks;
272 0: h_samp_factor = compptr->h_samp_factor;
273 : /* Count number of dummy blocks to be added at the right margin. */
274 0: ndummy = (int) (blocks_across % h_samp_factor);
0: branch 0 not taken
0: branch 1 not taken
275 0: if (ndummy > 0)
276 0: ndummy = h_samp_factor - ndummy;
277 : /* Perform DCT for all non-dummy blocks in this iMCU row. Each call
278 : * on forward_DCT processes a complete horizontal row of DCT blocks.
279 : */
0: branch 0 not taken
0: branch 1 not taken
280 0: for (block_row = 0; block_row < block_rows; block_row++) {
281 0: thisblockrow = buffer[block_row];
282 0: (*cinfo->fdct->forward_DCT) (cinfo, compptr,
283 0: input_buf[ci], thisblockrow,
284 0: (JDIMENSION) (block_row * DCTSIZE),
285 : (JDIMENSION) 0, blocks_across);
0: branch 0 not taken
0: branch 1 not taken
286 0: if (ndummy > 0) {
287 : /* Create dummy blocks at the right edge of the image. */
288 0: thisblockrow += blocks_across; /* => first dummy block */
289 0: jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
290 0: lastDC = thisblockrow[-1][0];
0: branch 0 not taken
0: branch 1 not taken
291 0: for (bi = 0; bi < ndummy; bi++) {
292 0: thisblockrow[bi][0] = lastDC;
293 : }
294 : }
295 : }
296 : /* If at end of image, create dummy block rows as needed.
297 : * The tricky part here is that within each MCU, we want the DC values
298 : * of the dummy blocks to match the last real block's DC value.
299 : * This squeezes a few more bytes out of the resulting file...
300 : */
0: branch 0 not taken
0: branch 1 not taken
301 0: if (coef->iMCU_row_num == last_iMCU_row) {
302 0: blocks_across += ndummy; /* include lower right corner */
303 0: MCUs_across = blocks_across / h_samp_factor;
0: branch 0 not taken
0: branch 1 not taken
304 0: for (block_row = block_rows; block_row < compptr->v_samp_factor;
305 0: block_row++) {
306 0: thisblockrow = buffer[block_row];
307 0: lastblockrow = buffer[block_row-1];
308 0: jzero_far((void FAR *) thisblockrow,
309 : (size_t) (blocks_across * SIZEOF(JBLOCK)));
0: branch 0 not taken
0: branch 1 not taken
310 0: for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
311 0: lastDC = lastblockrow[h_samp_factor-1][0];
0: branch 0 not taken
0: branch 1 not taken
312 0: for (bi = 0; bi < h_samp_factor; bi++) {
313 0: thisblockrow[bi][0] = lastDC;
314 : }
315 0: thisblockrow += h_samp_factor; /* advance to next MCU in row */
316 0: lastblockrow += h_samp_factor;
317 : }
318 : }
319 : }
320 : }
321 : /* NB: compress_output will increment iMCU_row_num if successful.
322 : * A suspension return will result in redoing all the work above next time.
323 : */
324 :
325 : /* Emit data to the entropy encoder, sharing code with subsequent passes */
326 0: return compress_output(cinfo, input_buf);
327 : }
328 :
329 :
330 : /*
331 : * Process some data in subsequent passes of a multi-pass case.
332 : * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
333 : * per call, ie, v_samp_factor block rows for each component in the scan.
334 : * The data is obtained from the virtual arrays and fed to the entropy coder.
335 : * Returns TRUE if the iMCU row is completed, FALSE if suspended.
336 : *
337 : * NB: input_buf is ignored; it is likely to be a NULL pointer.
338 : */
339 :
340 : METHODDEF(boolean)
341 0: compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
342 : {
343 0: my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
344 : JDIMENSION MCU_col_num; /* index of current MCU within row */
345 : int blkn, ci, xindex, yindex, yoffset;
346 : JDIMENSION start_col;
347 : JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
348 : JBLOCKROW buffer_ptr;
349 : jpeg_component_info *compptr;
350 :
351 : /* Align the virtual buffers for the components used in this scan.
352 : * NB: during first pass, this is safe only because the buffers will
353 : * already be aligned properly, so jmemmgr.c won't need to do any I/O.
354 : */
0: branch 0 not taken
0: branch 1 not taken
355 0: for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
356 0: compptr = cinfo->cur_comp_info[ci];
357 0: buffer[ci] = (*cinfo->mem->access_virt_barray)
358 0: ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
359 0: coef->iMCU_row_num * compptr->v_samp_factor,
360 0: (JDIMENSION) compptr->v_samp_factor, FALSE);
361 : }
362 :
363 : /* Loop to process one whole iMCU row */
0: branch 0 not taken
0: branch 1 not taken
364 0: for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
365 0: yoffset++) {
0: branch 0 not taken
0: branch 1 not taken
366 0: for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
367 0: MCU_col_num++) {
368 : /* Construct list of pointers to DCT blocks belonging to this MCU */
369 0: blkn = 0; /* index of current DCT block within MCU */
0: branch 0 not taken
0: branch 1 not taken
370 0: for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
371 0: compptr = cinfo->cur_comp_info[ci];
372 0: start_col = MCU_col_num * compptr->MCU_width;
0: branch 0 not taken
0: branch 1 not taken
373 0: for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
374 0: buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
0: branch 0 not taken
0: branch 1 not taken
375 0: for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
376 0: coef->MCU_buffer[blkn++] = buffer_ptr++;
377 : }
378 : }
379 : }
380 : /* Try to write the MCU. */
0: branch 1 not taken
0: branch 2 not taken
381 0: if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
382 : /* Suspension forced; update state counters and exit */
383 0: coef->MCU_vert_offset = yoffset;
384 0: coef->mcu_ctr = MCU_col_num;
385 0: return FALSE;
386 : }
387 : }
388 : /* Completed an MCU row, but perhaps not an iMCU row */
389 0: coef->mcu_ctr = 0;
390 : }
391 : /* Completed the iMCU row, advance counters for next one */
392 0: coef->iMCU_row_num++;
393 0: start_iMCU_row(cinfo);
394 0: return TRUE;
395 : }
396 :
397 : #endif /* FULL_COEF_BUFFER_SUPPORTED */
398 :
399 :
400 : /*
401 : * Initialize coefficient buffer controller.
402 : */
403 :
404 : GLOBAL(void)
405 4479: jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
406 : {
407 : my_coef_ptr coef;
408 :
409 4479: coef = (my_coef_ptr)
410 4479: (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
411 : SIZEOF(my_coef_controller));
412 4479: cinfo->coef = (struct jpeg_c_coef_controller *) coef;
413 4479: coef->pub.start_pass = start_pass_coef;
414 :
415 : /* Create the coefficient buffer. */
0: branch 0 not taken
4479: branch 1 taken
416 4479: if (need_full_buffer) {
417 : #ifdef FULL_COEF_BUFFER_SUPPORTED
418 : /* Allocate a full-image virtual array for each component, */
419 : /* padded to a multiple of samp_factor DCT blocks in each direction. */
420 : int ci;
421 : jpeg_component_info *compptr;
422 :
0: branch 0 not taken
0: branch 1 not taken
423 0: for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
424 0: ci++, compptr++) {
425 0: coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
426 0: ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
427 0: (JDIMENSION) jround_up((long) compptr->width_in_blocks,
428 0: (long) compptr->h_samp_factor),
429 0: (JDIMENSION) jround_up((long) compptr->height_in_blocks,
430 0: (long) compptr->v_samp_factor),
431 0: (JDIMENSION) compptr->v_samp_factor);
432 : }
433 : #else
434 : ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
435 : #endif
436 : } else {
437 : /* We only need a single-MCU buffer. */
438 : JBLOCKROW buffer;
439 : int i;
440 :
441 4479: buffer = (JBLOCKROW)
442 4479: (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
443 : C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
44790: branch 0 taken
4479: branch 1 taken
444 49269: for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
445 44790: coef->MCU_buffer[i] = buffer + i;
446 : }
447 4479: coef->whole_image[0] = NULL; /* flag for no virtual arrays */
448 : }
449 4479: }
Generated: 2016-04-07 18:20 by zcov


Notice board
Stay always up-to-date with notifications when new entries are added. Use the search function to filter the list to your need in no time!
Week plan
Get your personal week plan from the ZPA. Additionally you may create your own custom events for events outside your ZPA schedule. Get notifications when ever a plan change is recognized.
Room search
Ever wandered around and searched for a free room? Just enter the date and time you need a room and BOOM!
Appointments
Never lose track of important appointments as you'll receive a notification a day before!


EtchedLabel
This file was contributed by Instructor Roger Goudarzi. It shows a number of aspects including window actions, button actions, and graphics.
EtchedLabel.java
, the graphics part
MyFrame.java
, the frame
MyGuiApp.java
, the main program


{% extends "base.html" %} {% block content %}
Broken :(
Import just the tweets.js file from your archive
tweets.js


radioModel
is {{ selected }}.
A radio button can be created by using the ux-radio-button
component placed inside a
uxRadioButtonGroup
. In order to use the radio button in a reactive form, define the
formControlName
property on the uxRadioButtonGroup
element. The following
attributes can be used to configure the appearance and behavior of the component:
value
variable.
value
variable when the radio button is selected. No two radio buttons should have the same option
value within the same group of radio buttons.
true
the checkbox will be displayed without a border and background.
true
the checkbox will not toggle state when clicked.
true
the radio button will be marked as required.
In addition to the options listed above, a radio button can be disabled using the disabled
attribute. You can also provide
the radio button with a name
or id
if required.
It is impossible to land keyboard focus on a radio button group when the selected
option is
disabled
. As a workaround we recommend removing the selected
state from
the ux-radio-button
when disabling it. We have provided a workaround in our example
code.
The following code can be used to create the example above:


Various Functions
Please, fill out the various fields and then click the corresponding button to get your answer
Enter a number(x) to apply its factorial (x!)
Factorial number:
Factor!
Your factorial:
! =
*
=
Your factorial (done recursively):
! =
*
=


Backblaze Privacy Notice
Last updated: July 10, 2018
We value your business and we know your privacy is important to you.
Accordingly, we have implemented this Privacy Notice which describes:
how we collect and use personal information that you provide to us when
you create a Backblaze account, via our website or Apps; what we do with
the information collected; and how you can exercise your privacy rights.
This Privacy Notice applies only to the information collected in respect of
your account and does not apply to the content that customers store on our
system, including any personal information. Backblaze will not disclose,
move, access or use customer content except as provided in Backblaze's
terms and conditions, and our
data processing addendum.
Backblaze is a US headquartered data storage provider that offers two different products:
-
Computer Backup, which
provides unlimited cloud backup for individuals and organizations
using Macs or PCs (laptops and desktops); and
-
B2 Cloud Storage, which
provides low-cost cloud storage for individuals and organizations.
When requesting to use Backblaze's services we may ask you to provide personal information to us.
For example, when you create a Backblaze account, we will ask you for your email address and a password.
We may also ask for your phone number for purposes such as two-factor verification or for sending you
service alerts. If you choose to sign up for one of Backblaze's services, we will ask you for billing
information. To order a physical item from us, such as a Restore by Mail, we will ask for shipping details.
At times we may ask for other information such as your name or the name of your company name.
During your interaction with Backblaze, you may choose to provide us with personal information when you email
us, chat with us, answer a survey, comment on our blog, or communicate with us through social media services
like Twitter or Facebook.
If you refer a friend to Backblaze, we will ask you for their email address. Backblaze will then contact your
referred friend to determine whether your friend consents to us contacting them.
Our Computer Backup service automatically backs up your files to Backblaze; B2 Cloud Storage allows you to upload
your files to our service. While the content of your files may include personally identifiable information, both
in the content of a file and in metadata, this Privacy Notice, as stated at the outset, only applies to the
information collected in respect of your account and not to the content that you store on our system.
When you use any Backblaze product we may collect certain information automatically from and about your device.
This includes data about your software, the operating system you use when accessing our service, your Internet
Protocol address and the date and time of each request you make to Backblaze. When you use our backup services,
we will also receive information such as the names of external drives, file types transferred, and number and
size of files transferred.
Collecting this information enables us to better diagnose problems with our products, provide customer support
more effectively, inform you about operating systems we no longer support as well as ensure the continuous
functionality of our products.
We may collect additional information about you from third parties primarily to assist us in understanding how we
can maintain and improve the services we offer to better serve you. Third party tools that we use for this are
from: Optimizely, which records a user's clicks and enables Backblaze to test different versions of its website;
HotJar, which is used to record where people move their mouse on key web pages; and Google Analytics which informs
Backblaze about page visits which in turn allows Backblaze to decide if it needs to update certain pages.
SurveyMonkey, which Backblaze uses to distribute surveys, which users can voluntarily complete,
will collect a user's IP address.
Under no circumstances do we rent, trade or share your address or e-mail address with any other company for their
marketing purposes without your consent. We may use the information we collect through our products for a number
of reasons, including to:
- provide, operate, optimize and maintain our online platforms, products and services;
- understand how you use our products and customize your experience;
- set up online accounts;
- process, fulfill and provide any updates on online orders;
-
send you marketing communications we think you'll find valuable, where it is in accordance with your preferences;
-
provide customer support via online chat services; deal with your online enquiries and requests sent by email;
and provide you with information and access to resources or services that you have requested from us;
- improve the layout, navigation and content of our online products;
- identify any server problems or other IT or network issues;
- prevent abuse of the products and services we offer; and
-
carry out other legitimate business purposes, such as to improve our products and services, as well as other
lawful purposes about which we will notify our users and clients.
From time to time, Backblaze will communicate with you via email. There are two types of email you may receive:
-
Service Emails: These are service related emails such as confirmation
of password change, expiration of credit card, or a reply to a support issue. You cannot opt out of receiving
these messages as they are part of the service which Backblaze provides to you. You can manage certain Service
Emails by signing in to your Account. To stop receiving all Service Emails, you must cancel the service and
uninstall the Backblaze software from your devices.
-
Marketing Emails: These will include Backblaze company news,
tips-and-tricks, service promotions (e.g., refer-a-friend) and similar types of material.
Upon creating a Backblaze Account you will be able to manage your email preferences, including
opting out of receiving all Marketing Emails. You will also be able to unsubscribe at any time
by using the unsubscribe link provided in any given email.
We will only process personal information in ways that are compatible with the purpose we collected it for or
for the purposes you later authorise. Before we use your personal information for a purpose that is materially
different than the purpose we collected it for or that you later authorised, we will provide you with the opportunity
to opt-out.
We may share and disclose your personally identifiable information only in the limited circumstances described below:
-
To vendors and other third party service providers who require access to your personal information to assist
in providing and improving our products. The third parties that access and use your information only on our
behalf include companies such as Stripe, Salesforce, Google Analytics, Freshbooks, Facebook, Twitter, Hubspot,
MailChimp, Plivo, Slack, SurveyMonkey, SendGrid, Twillio, and ZenDesk. For example, we partner with Stripe and
Freshbooks to assist us in processing your payment; Hubspot enables us to send you marketing emails, subject to
your preferences; SendGrid is used to communicate service emails to you; Twillio and Plivo are used to send SMS
messages to you when you use our 2-factor authentication feature; and Zendesk is used to facilitate our customer
support and online Chat service.
-
We may also disclose your information to third parties: (a) where required by law or regulatory requirement,
court order or other judicial authorization, (b) in response to lawful requests by public authorities, including
for the purposes of meeting national security and law enforcement requirements; (c) in connection with the sale,
transfer, merger, bankruptcy, restructuring or other reorganization of a business; (d) to protect or defend our
rights, interests or property, or that of third parties; (e) to investigate any wrongdoing in connection with our
products and services; and (f) to protect the vital interests of an individual.
- To any other person with your consent.
-
If you use our services as part of a business, group, or organization where Backblaze was set up by an administrator,
the administrator may be able to access and control your account. Refer to your organization's internal policies for
more information.
-
B2 Cloud Storage users can give third parties the ability to access information and content in their account
(e.g., through APIs). When other services access and use your information, their conduct is governed by their own
terms and policies.
-
The settings for B2 Cloud Storage also give you the option to make information and content available to other people.
- We may disclose aggregate, non-identifying information about how our users use Backblaze products.
If you are a visitor/customer located in the European Economic Area ("EEA"), our legal basis for collecting and using the
personal information described above will depend on the personal information concerned and the specific context in which we
collect it. We will normally collect personal information from you only where we have your consent to do so, where we need
the personal information to perform a contract with you, or where the processing is in our legitimate business interests.
In some cases, we may also have a legal obligation to collect personal information from you.
If we ask you to provide personal information to comply with a legal requirement or to enter into a contract with you, we
will make this clear at the relevant time and advise you whether the provision of your personal information is mandatory or
not (as well as of the possible consequences if you do not provide your personal information). Similarly, if we collect and
use your personal information in reliance on our legitimate business interests, we will make clear to you at the relevant time
what those legitimate business interests are.
If you have questions about or need further information concerning the legal basis on which we collect and use your personal
information, please contact us using the contact details provided under the
'How to contact us' heading below.
Like all e-commerce websites we use cookies and similar tracking technology (collectively "Cookies") to collect and use personal
information about you. For further information about the types of Cookies we and our partners' use, why and how you can control
Cookies, please see our
Cookie Statement.
Your personal information is stored and processed by us in the U.S. Specifically, your personal and non-personal information will be transferred to Backblaze for storage and processing in the U.S.
When transferring any personal information from the EEA and Switzerland to the U.S., we adhere to the EU-U.S. and Swiss-U.S. Privacy Shield Frameworks, as set forth by the U.S. Department of Commerce. Backblaze has certified adherence to and commits to apply the Privacy Shield Principles to all personal information it processes in reliance on the Shield.
For the purposes of enforcing compliance with the Privacy Shield, we are subject to the investigatory and enforcement authority of the U.S. Federal Trade Commission.
For more information about the Privacy Shield, and to view our certification, see the U.S. Department of Commerce’s Privacy Shield website located at:
https://www.privacyshield.gov.
If we have received your personal information in the U.S. and subsequently transfer it to a third-party agent or service provider for processing, and such third party agent or service provider processes your personal information in a manner inconsistent with the Privacy Shield Principles, we remain responsible under the Privacy Shield unless we can prove we are not responsible for the event giving rise to the damage.
You can direct any questions or complaints about the use or disclosure of your personal information to us at
[email protected]. We will investigate and resolve any complaints or disputes regarding the use of personal information within forty-five (45) days of receiving your complaint.
We have further committed to using
the American Arbitration Association (AAA) to provide an independent recourse method.
AAA will handle any complaints Backblaze is unable to resolve.
You may have the option to select binding arbitration for the resolution of your complaint under certain circumstances. To find out more about the Privacy Shield's binding arbitration scheme please see
https://www.privacyshield.gov/article?id=ANNEX-I-introduction.
For information on how to request access, rectification or deletion of your personal information if it is inaccurate or processed in violation of the Privacy Shield, see
Section 10 below on "Your data protection rights & choices".
The security of your personal information is very important to us.
When you enter personal information such as a credit card number on our website or via our App we encrypt that information
using secure socket layer technology (SSL). For purchases made online with credit cards, we receive your credit card number
in encrypted form, and transfer it to our credit card processor, Stripe, for processing. Our employees do not have access to
this information. We do not store PIN data or 3-digit security codes.
We use appropriate technical and organizational security measures to protect your personal information from loss, misuse,
and unauthorized access, disclosure, alteration and destruction, both during transmission and once we receive it. However,
no method of transmission over the Internet, or method of electronic storage, is 100% secure. Therefore we cannot guarantee
its absolute security.
You have the following rights:
-
If you wish to access your personal information that Backblaze collects, you can do so at any time by contacting
us using the contact details provided under 'How to contact us' heading below.
-
You can correct, update or request deletion of your details in your Account by logging in to your Account. You
can also contact us using the contact details provided under 'How to contact us' heading below in order
to request that your data is deleted.
-
If you are a resident of the EEA, you can object to processing of your personal information, ask us to
restrict processing of your personal information or request portability of your personal information where
it is technically possible. Again, you can exercise these rights by contacting us using the contact details below.
-
Similarly, if we have collected and processed your personal information with your consent, then you can withdraw your consent
at any time. Withdrawing your consent will not affect the lawfulness of any processing we conducted prior to your withdrawal, nor will it
affect processing of your personal information conducted in reliance on lawful processing grounds other than consent.
-
You have the right to complain to a data protection authority about our collection and use of your personal information.
Contact details for data protection authorities in the EEA, Switzerland and certain non-European countries (including the U.S. and Canada)
are available here.)
You have the right to
opt-out of marketing communications we send you at any time. You can exercise this right by clicking
on the “unsubscribe” link in the marketing e-mails we send you. Alternatively, please contact us at
[email protected]. Please include your complete name and e-mail address. Note that it may take
up to 3 business days to remove you from our marketing lists and after this point you will still receive Service Emails from us.
We respond to all requests we receive from individuals wishing to exercise their data protection rights in accordance with applicable data
protection laws.
Our Website contains links to third party websites and third party plug-ins (such as social media sharing buttons) operated by other companies.
We are not responsible for the privacy practices of such other websites. We encourage you to be aware that when you leave our site you read the
privacy notices of such other websites. This Privacy Notice applies solely to information collected by Backblaze's products.
We will retain your personal information for the period necessary to fulfil the purposes outlined in this Privacy Notice unless a longer
retention period is required or permitted by law, for legal, tax or regulatory reasons, or other lawful purposes.
When we have no ongoing legitimate business need to process your personal information, we will either delete or anonymize it or, if this is
not possible (for example, because your personal information has been stored in backup archives), then we will securely store your personal
information and isolate it from any further processing until deletion is possible.
Changes to this Privacy Notice will be made when required in response to changing legal, technical or business developments. When we update
our Privacy Notice, we will take appropriate measures to inform you, consistent with the significance of the changes we make.
We will obtain your consent to any material Privacy Notice changes if and where this is required by applicable data protection laws.
You can see when this Privacy Notice was last updated by checking the “last updated” date displayed at the top of this Privacy Notice.
The new Privacy Notice will apply to all current and past users of the website and will replace any prior notices that are inconsistent with it.
If you have any questions or concerns regarding the use or disclosure of your personal information, you can contact us by sending an email
to
[email protected] or by contacting us at:
500 Ben Franklin Ct,
San Mateo, CA 94401, U.S.
+1<PHONE_NUMBER>
Please note that for the purposes of EU data protection legislation, Backblaze is the controller of your personal information.


A C E G H I M O P R S T
A
- addMinutes(int) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Add minutes to the current time
C
- com.mycompany.hw7_mehmed_mustafa_131044084 - package com.mycompany.hw7_mehmed_mustafa_131044084
-
- compareTo(Object) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Passenger
-
- compareTo(Timer) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Comparing method
E
- equals(Object) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Person
-
Method to check if two objects are same person
G
- get(K) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmeDChainHash
-
Get the value for the given key
- getArrivalTime() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Passenger
-
Arrival time getter
- getCustomerType() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Passenger
-
Customer type getter
- getHour() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Hours getter
- getMinute() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Minutes getter
- getRandomIDs(ArrayList, ArrayList) - Static method in class com.mycompany.hw7_mehmed_mustafa_131044084.mainTester
-
- getServiceTime() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Passenger
-
Service time getter
- getTime() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Timer getter
H
- hashCode() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Person
-
Method for hashing the person information
I
- increaseMinutes(int) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Add minutes to the current time without changing current time
- isEmpty() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Checker for emptiness of the queue
- iterator() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Iterator
M
- main(String[]) - Static method in class com.mycompany.hw7_mehmed_mustafa_131044084.mainTester
-
- mainTester - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
- mainTester() - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.mainTester
-
- MehmeDChainHash<K,V> - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
Chain Hash Table Class
- MehmeDChainHash() - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.MehmeDChainHash
-
Default Constructor
- MehmedsPriorityQueue<E> - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
Priority queue class
- MehmedsPriorityQueue() - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Default constructor
- MehmedsPriorityQueue(Comparator<E>) - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Constructor with initialized comparator
- MehmedsSimulation - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
Simulation class
- MehmedsSimulation() - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsSimulation
-
Default Constructor
O
- offer(E) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Method for adding new element
P
- Passenger - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
Passenger class to track the passengers information
- Passenger(Timer, int, int) - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.Passenger
-
- peek() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Method for checking the first element of the queue
- Person - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
Person class
- Person(String, String, int, int) - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.Person
-
Constructor
- Person(int, int) - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.Person
-
Constructor
- poll() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Method for getting and removing the first element of the queue
- put(K, V) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmeDChainHash
-
Put the value with the given key
R
- randNum(int, int) - Static method in class com.mycompany.hw7_mehmed_mustafa_131044084.mainTester
-
- remove(K) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmeDChainHash
-
Removes the key entry
S
- setHour(int) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Hours setter
- setMinute(int) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Minutes setter
- size() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsPriorityQueue
-
Checker for the size of the queue
- startSimulation(String, String) - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.MehmedsSimulation
-
Method to start simulation process
T
- Timer - Class in com.mycompany.hw7_mehmed_mustafa_131044084
-
Timer class to check time of the simulation
- Timer() - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Default constructor
- Timer(int, int) - Constructor for class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
Constructor with 2 parameters
- toString() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Passenger
-
- toString() - Method in class com.mycompany.hw7_mehmed_mustafa_131044084.Timer
-
A C E G H I M O P R S T
Copyright © 2016. All rights reserved.