Commit | Line | Data |
---|---|---|
6a1aa64f DV |
1 | /*** |
2 | ||
3 | MochiKit.Iter 1.4 | |
4 | ||
5 | See <http://mochikit.com/> for documentation, downloads, license, etc. | |
6 | ||
7 | (c) 2005 Bob Ippolito. All rights Reserved. | |
8 | ||
9 | ***/ | |
10 | ||
11 | if (typeof(dojo) != 'undefined') { | |
12 | dojo.provide('MochiKit.Iter'); | |
13 | dojo.require('MochiKit.Base'); | |
14 | } | |
15 | ||
16 | if (typeof(JSAN) != 'undefined') { | |
17 | JSAN.use("MochiKit.Base", []); | |
18 | } | |
19 | ||
20 | try { | |
21 | if (typeof(MochiKit.Base) == 'undefined') { | |
22 | throw ""; | |
23 | } | |
24 | } catch (e) { | |
25 | throw "MochiKit.Iter depends on MochiKit.Base!"; | |
26 | } | |
27 | ||
28 | if (typeof(MochiKit.Iter) == 'undefined') { | |
29 | MochiKit.Iter = {}; | |
30 | } | |
31 | ||
32 | MochiKit.Iter.NAME = "MochiKit.Iter"; | |
33 | MochiKit.Iter.VERSION = "1.4"; | |
34 | MochiKit.Base.update(MochiKit.Iter, { | |
35 | __repr__: function () { | |
36 | return "[" + this.NAME + " " + this.VERSION + "]"; | |
37 | }, | |
38 | toString: function () { | |
39 | return this.__repr__(); | |
40 | }, | |
41 | ||
42 | /** @id MochiKit.Iter.registerIteratorFactory */ | |
43 | registerIteratorFactory: function (name, check, iterfactory, /* optional */ override) { | |
44 | MochiKit.Iter.iteratorRegistry.register(name, check, iterfactory, override); | |
45 | }, | |
46 | ||
47 | /** @id MochiKit.Iter.iter */ | |
48 | iter: function (iterable, /* optional */ sentinel) { | |
49 | var self = MochiKit.Iter; | |
50 | if (arguments.length == 2) { | |
51 | return self.takewhile( | |
52 | function (a) { return a != sentinel; }, | |
53 | iterable | |
54 | ); | |
55 | } | |
56 | if (typeof(iterable.next) == 'function') { | |
57 | return iterable; | |
58 | } else if (typeof(iterable.iter) == 'function') { | |
59 | return iterable.iter(); | |
60 | /* | |
61 | } else if (typeof(iterable.__iterator__) == 'function') { | |
62 | // | |
63 | // XXX: We can't support JavaScript 1.7 __iterator__ directly | |
64 | // because of Object.prototype.__iterator__ | |
65 | // | |
66 | return iterable.__iterator__(); | |
67 | */ | |
68 | } | |
69 | ||
70 | try { | |
71 | return self.iteratorRegistry.match(iterable); | |
72 | } catch (e) { | |
73 | var m = MochiKit.Base; | |
74 | if (e == m.NotFound) { | |
75 | e = new TypeError(typeof(iterable) + ": " + m.repr(iterable) + " is not iterable"); | |
76 | } | |
77 | throw e; | |
78 | } | |
79 | }, | |
80 | ||
81 | /** @id MochiKit.Iter.count */ | |
82 | count: function (n) { | |
83 | if (!n) { | |
84 | n = 0; | |
85 | } | |
86 | var m = MochiKit.Base; | |
87 | return { | |
88 | repr: function () { return "count(" + n + ")"; }, | |
89 | toString: m.forwardCall("repr"), | |
90 | next: m.counter(n) | |
91 | }; | |
92 | }, | |
93 | ||
94 | /** @id MochiKit.Iter.cycle */ | |
95 | cycle: function (p) { | |
96 | var self = MochiKit.Iter; | |
97 | var m = MochiKit.Base; | |
98 | var lst = []; | |
99 | var iterator = self.iter(p); | |
100 | return { | |
101 | repr: function () { return "cycle(...)"; }, | |
102 | toString: m.forwardCall("repr"), | |
103 | next: function () { | |
104 | try { | |
105 | var rval = iterator.next(); | |
106 | lst.push(rval); | |
107 | return rval; | |
108 | } catch (e) { | |
109 | if (e != self.StopIteration) { | |
110 | throw e; | |
111 | } | |
112 | if (lst.length === 0) { | |
113 | this.next = function () { | |
114 | throw self.StopIteration; | |
115 | }; | |
116 | } else { | |
117 | var i = -1; | |
118 | this.next = function () { | |
119 | i = (i + 1) % lst.length; | |
120 | return lst[i]; | |
121 | }; | |
122 | } | |
123 | return this.next(); | |
124 | } | |
125 | } | |
126 | }; | |
127 | }, | |
128 | ||
129 | /** @id MochiKit.Iter.repeat */ | |
130 | repeat: function (elem, /* optional */n) { | |
131 | var m = MochiKit.Base; | |
132 | if (typeof(n) == 'undefined') { | |
133 | return { | |
134 | repr: function () { | |
135 | return "repeat(" + m.repr(elem) + ")"; | |
136 | }, | |
137 | toString: m.forwardCall("repr"), | |
138 | next: function () { | |
139 | return elem; | |
140 | } | |
141 | }; | |
142 | } | |
143 | return { | |
144 | repr: function () { | |
145 | return "repeat(" + m.repr(elem) + ", " + n + ")"; | |
146 | }, | |
147 | toString: m.forwardCall("repr"), | |
148 | next: function () { | |
149 | if (n <= 0) { | |
150 | throw MochiKit.Iter.StopIteration; | |
151 | } | |
152 | n -= 1; | |
153 | return elem; | |
154 | } | |
155 | }; | |
156 | }, | |
157 | ||
158 | /** @id MochiKit.Iter.next */ | |
159 | next: function (iterator) { | |
160 | return iterator.next(); | |
161 | }, | |
162 | ||
163 | /** @id MochiKit.Iter.izip */ | |
164 | izip: function (p, q/*, ...*/) { | |
165 | var m = MochiKit.Base; | |
166 | var self = MochiKit.Iter; | |
167 | var next = self.next; | |
168 | var iterables = m.map(self.iter, arguments); | |
169 | return { | |
170 | repr: function () { return "izip(...)"; }, | |
171 | toString: m.forwardCall("repr"), | |
172 | next: function () { return m.map(next, iterables); } | |
173 | }; | |
174 | }, | |
175 | ||
176 | /** @id MochiKit.Iter.ifilter */ | |
177 | ifilter: function (pred, seq) { | |
178 | var m = MochiKit.Base; | |
179 | seq = MochiKit.Iter.iter(seq); | |
180 | if (pred === null) { | |
181 | pred = m.operator.truth; | |
182 | } | |
183 | return { | |
184 | repr: function () { return "ifilter(...)"; }, | |
185 | toString: m.forwardCall("repr"), | |
186 | next: function () { | |
187 | while (true) { | |
188 | var rval = seq.next(); | |
189 | if (pred(rval)) { | |
190 | return rval; | |
191 | } | |
192 | } | |
193 | // mozilla warnings aren't too bright | |
194 | return undefined; | |
195 | } | |
196 | }; | |
197 | }, | |
198 | ||
199 | /** @id MochiKit.Iter.ifilterfalse */ | |
200 | ifilterfalse: function (pred, seq) { | |
201 | var m = MochiKit.Base; | |
202 | seq = MochiKit.Iter.iter(seq); | |
203 | if (pred === null) { | |
204 | pred = m.operator.truth; | |
205 | } | |
206 | return { | |
207 | repr: function () { return "ifilterfalse(...)"; }, | |
208 | toString: m.forwardCall("repr"), | |
209 | next: function () { | |
210 | while (true) { | |
211 | var rval = seq.next(); | |
212 | if (!pred(rval)) { | |
213 | return rval; | |
214 | } | |
215 | } | |
216 | // mozilla warnings aren't too bright | |
217 | return undefined; | |
218 | } | |
219 | }; | |
220 | }, | |
221 | ||
222 | /** @id MochiKit.Iter.islice */ | |
223 | islice: function (seq/*, [start,] stop[, step] */) { | |
224 | var self = MochiKit.Iter; | |
225 | var m = MochiKit.Base; | |
226 | seq = self.iter(seq); | |
227 | var start = 0; | |
228 | var stop = 0; | |
229 | var step = 1; | |
230 | var i = -1; | |
231 | if (arguments.length == 2) { | |
232 | stop = arguments[1]; | |
233 | } else if (arguments.length == 3) { | |
234 | start = arguments[1]; | |
235 | stop = arguments[2]; | |
236 | } else { | |
237 | start = arguments[1]; | |
238 | stop = arguments[2]; | |
239 | step = arguments[3]; | |
240 | } | |
241 | return { | |
242 | repr: function () { | |
243 | return "islice(" + ["...", start, stop, step].join(", ") + ")"; | |
244 | }, | |
245 | toString: m.forwardCall("repr"), | |
246 | next: function () { | |
247 | var rval; | |
248 | while (i < start) { | |
249 | rval = seq.next(); | |
250 | i++; | |
251 | } | |
252 | if (start >= stop) { | |
253 | throw self.StopIteration; | |
254 | } | |
255 | start += step; | |
256 | return rval; | |
257 | } | |
258 | }; | |
259 | }, | |
260 | ||
261 | /** @id MochiKit.Iter.imap */ | |
262 | imap: function (fun, p, q/*, ...*/) { | |
263 | var m = MochiKit.Base; | |
264 | var self = MochiKit.Iter; | |
265 | var iterables = m.map(self.iter, m.extend(null, arguments, 1)); | |
266 | var map = m.map; | |
267 | var next = self.next; | |
268 | return { | |
269 | repr: function () { return "imap(...)"; }, | |
270 | toString: m.forwardCall("repr"), | |
271 | next: function () { | |
272 | return fun.apply(this, map(next, iterables)); | |
273 | } | |
274 | }; | |
275 | }, | |
276 | ||
277 | /** @id MochiKit.Iter.applymap */ | |
278 | applymap: function (fun, seq, self) { | |
279 | seq = MochiKit.Iter.iter(seq); | |
280 | var m = MochiKit.Base; | |
281 | return { | |
282 | repr: function () { return "applymap(...)"; }, | |
283 | toString: m.forwardCall("repr"), | |
284 | next: function () { | |
285 | return fun.apply(self, seq.next()); | |
286 | } | |
287 | }; | |
288 | }, | |
289 | ||
290 | /** @id MochiKit.Iter.chain */ | |
291 | chain: function (p, q/*, ...*/) { | |
292 | // dumb fast path | |
293 | var self = MochiKit.Iter; | |
294 | var m = MochiKit.Base; | |
295 | if (arguments.length == 1) { | |
296 | return self.iter(arguments[0]); | |
297 | } | |
298 | var argiter = m.map(self.iter, arguments); | |
299 | return { | |
300 | repr: function () { return "chain(...)"; }, | |
301 | toString: m.forwardCall("repr"), | |
302 | next: function () { | |
303 | while (argiter.length > 1) { | |
304 | try { | |
305 | return argiter[0].next(); | |
306 | } catch (e) { | |
307 | if (e != self.StopIteration) { | |
308 | throw e; | |
309 | } | |
310 | argiter.shift(); | |
311 | } | |
312 | } | |
313 | if (argiter.length == 1) { | |
314 | // optimize last element | |
315 | var arg = argiter.shift(); | |
316 | this.next = m.bind("next", arg); | |
317 | return this.next(); | |
318 | } | |
319 | throw self.StopIteration; | |
320 | } | |
321 | }; | |
322 | }, | |
323 | ||
324 | /** @id MochiKit.Iter.takewhile */ | |
325 | takewhile: function (pred, seq) { | |
326 | var self = MochiKit.Iter; | |
327 | seq = self.iter(seq); | |
328 | return { | |
329 | repr: function () { return "takewhile(...)"; }, | |
330 | toString: MochiKit.Base.forwardCall("repr"), | |
331 | next: function () { | |
332 | var rval = seq.next(); | |
333 | if (!pred(rval)) { | |
334 | this.next = function () { | |
335 | throw self.StopIteration; | |
336 | }; | |
337 | this.next(); | |
338 | } | |
339 | return rval; | |
340 | } | |
341 | }; | |
342 | }, | |
343 | ||
344 | /** @id MochiKit.Iter.dropwhile */ | |
345 | dropwhile: function (pred, seq) { | |
346 | seq = MochiKit.Iter.iter(seq); | |
347 | var m = MochiKit.Base; | |
348 | var bind = m.bind; | |
349 | return { | |
350 | "repr": function () { return "dropwhile(...)"; }, | |
351 | "toString": m.forwardCall("repr"), | |
352 | "next": function () { | |
353 | while (true) { | |
354 | var rval = seq.next(); | |
355 | if (!pred(rval)) { | |
356 | break; | |
357 | } | |
358 | } | |
359 | this.next = bind("next", seq); | |
360 | return rval; | |
361 | } | |
362 | }; | |
363 | }, | |
364 | ||
365 | _tee: function (ident, sync, iterable) { | |
366 | sync.pos[ident] = -1; | |
367 | var m = MochiKit.Base; | |
368 | var listMin = m.listMin; | |
369 | return { | |
370 | repr: function () { return "tee(" + ident + ", ...)"; }, | |
371 | toString: m.forwardCall("repr"), | |
372 | next: function () { | |
373 | var rval; | |
374 | var i = sync.pos[ident]; | |
375 | ||
376 | if (i == sync.max) { | |
377 | rval = iterable.next(); | |
378 | sync.deque.push(rval); | |
379 | sync.max += 1; | |
380 | sync.pos[ident] += 1; | |
381 | } else { | |
382 | rval = sync.deque[i - sync.min]; | |
383 | sync.pos[ident] += 1; | |
384 | if (i == sync.min && listMin(sync.pos) != sync.min) { | |
385 | sync.min += 1; | |
386 | sync.deque.shift(); | |
387 | } | |
388 | } | |
389 | return rval; | |
390 | } | |
391 | }; | |
392 | }, | |
393 | ||
394 | /** @id MochiKit.Iter.tee */ | |
395 | tee: function (iterable, n/* = 2 */) { | |
396 | var rval = []; | |
397 | var sync = { | |
398 | "pos": [], | |
399 | "deque": [], | |
400 | "max": -1, | |
401 | "min": -1 | |
402 | }; | |
403 | if (arguments.length == 1 || typeof(n) == "undefined" || n === null) { | |
404 | n = 2; | |
405 | } | |
406 | var self = MochiKit.Iter; | |
407 | iterable = self.iter(iterable); | |
408 | var _tee = self._tee; | |
409 | for (var i = 0; i < n; i++) { | |
410 | rval.push(_tee(i, sync, iterable)); | |
411 | } | |
412 | return rval; | |
413 | }, | |
414 | ||
415 | /** @id MochiKit.Iter.list */ | |
416 | list: function (iterable) { | |
417 | // Fast-path for Array and Array-like | |
418 | var rval; | |
419 | if (iterable instanceof Array) { | |
420 | return iterable.slice(); | |
421 | } | |
422 | // this is necessary to avoid a Safari crash | |
423 | if (typeof(iterable) == "function" && | |
424 | !(iterable instanceof Function) && | |
425 | typeof(iterable.length) == 'number') { | |
426 | rval = []; | |
427 | for (var i = 0; i < iterable.length; i++) { | |
428 | rval.push(iterable[i]); | |
429 | } | |
430 | return rval; | |
431 | } | |
432 | ||
433 | var self = MochiKit.Iter; | |
434 | iterable = self.iter(iterable); | |
435 | var rval = []; | |
436 | try { | |
437 | while (true) { | |
438 | rval.push(iterable.next()); | |
439 | } | |
440 | } catch (e) { | |
441 | if (e != self.StopIteration) { | |
442 | throw e; | |
443 | } | |
444 | return rval; | |
445 | } | |
446 | // mozilla warnings aren't too bright | |
447 | return undefined; | |
448 | }, | |
449 | ||
450 | ||
451 | /** @id MochiKit.Iter.reduce */ | |
452 | reduce: function (fn, iterable, /* optional */initial) { | |
453 | var i = 0; | |
454 | var x = initial; | |
455 | var self = MochiKit.Iter; | |
456 | iterable = self.iter(iterable); | |
457 | if (arguments.length < 3) { | |
458 | try { | |
459 | x = iterable.next(); | |
460 | } catch (e) { | |
461 | if (e == self.StopIteration) { | |
462 | e = new TypeError("reduce() of empty sequence with no initial value"); | |
463 | } | |
464 | throw e; | |
465 | } | |
466 | i++; | |
467 | } | |
468 | try { | |
469 | while (true) { | |
470 | x = fn(x, iterable.next()); | |
471 | } | |
472 | } catch (e) { | |
473 | if (e != self.StopIteration) { | |
474 | throw e; | |
475 | } | |
476 | } | |
477 | return x; | |
478 | }, | |
479 | ||
480 | /** @id MochiKit.Iter.range */ | |
481 | range: function (/* [start,] stop[, step] */) { | |
482 | var start = 0; | |
483 | var stop = 0; | |
484 | var step = 1; | |
485 | if (arguments.length == 1) { | |
486 | stop = arguments[0]; | |
487 | } else if (arguments.length == 2) { | |
488 | start = arguments[0]; | |
489 | stop = arguments[1]; | |
490 | } else if (arguments.length == 3) { | |
491 | start = arguments[0]; | |
492 | stop = arguments[1]; | |
493 | step = arguments[2]; | |
494 | } else { | |
495 | throw new TypeError("range() takes 1, 2, or 3 arguments!"); | |
496 | } | |
497 | if (step === 0) { | |
498 | throw new TypeError("range() step must not be 0"); | |
499 | } | |
500 | return { | |
501 | next: function () { | |
502 | if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) { | |
503 | throw MochiKit.Iter.StopIteration; | |
504 | } | |
505 | var rval = start; | |
506 | start += step; | |
507 | return rval; | |
508 | }, | |
509 | repr: function () { | |
510 | return "range(" + [start, stop, step].join(", ") + ")"; | |
511 | }, | |
512 | toString: MochiKit.Base.forwardCall("repr") | |
513 | }; | |
514 | }, | |
515 | ||
516 | /** @id MochiKit.Iter.sum */ | |
517 | sum: function (iterable, start/* = 0 */) { | |
518 | if (typeof(start) == "undefined" || start === null) { | |
519 | start = 0; | |
520 | } | |
521 | var x = start; | |
522 | var self = MochiKit.Iter; | |
523 | iterable = self.iter(iterable); | |
524 | try { | |
525 | while (true) { | |
526 | x += iterable.next(); | |
527 | } | |
528 | } catch (e) { | |
529 | if (e != self.StopIteration) { | |
530 | throw e; | |
531 | } | |
532 | } | |
533 | return x; | |
534 | }, | |
535 | ||
536 | /** @id MochiKit.Iter.exhaust */ | |
537 | exhaust: function (iterable) { | |
538 | var self = MochiKit.Iter; | |
539 | iterable = self.iter(iterable); | |
540 | try { | |
541 | while (true) { | |
542 | iterable.next(); | |
543 | } | |
544 | } catch (e) { | |
545 | if (e != self.StopIteration) { | |
546 | throw e; | |
547 | } | |
548 | } | |
549 | }, | |
550 | ||
551 | /** @id MochiKit.Iter.forEach */ | |
552 | forEach: function (iterable, func, /* optional */self) { | |
553 | var m = MochiKit.Base; | |
554 | if (arguments.length > 2) { | |
555 | func = m.bind(func, self); | |
556 | } | |
557 | // fast path for array | |
558 | if (m.isArrayLike(iterable)) { | |
559 | try { | |
560 | for (var i = 0; i < iterable.length; i++) { | |
561 | func(iterable[i]); | |
562 | } | |
563 | } catch (e) { | |
564 | if (e != MochiKit.Iter.StopIteration) { | |
565 | throw e; | |
566 | } | |
567 | } | |
568 | } else { | |
569 | self = MochiKit.Iter; | |
570 | self.exhaust(self.imap(func, iterable)); | |
571 | } | |
572 | }, | |
573 | ||
574 | /** @id MochiKit.Iter.every */ | |
575 | every: function (iterable, func) { | |
576 | var self = MochiKit.Iter; | |
577 | try { | |
578 | self.ifilterfalse(func, iterable).next(); | |
579 | return false; | |
580 | } catch (e) { | |
581 | if (e != self.StopIteration) { | |
582 | throw e; | |
583 | } | |
584 | return true; | |
585 | } | |
586 | }, | |
587 | ||
588 | /** @id MochiKit.Iter.sorted */ | |
589 | sorted: function (iterable, /* optional */cmp) { | |
590 | var rval = MochiKit.Iter.list(iterable); | |
591 | if (arguments.length == 1) { | |
592 | cmp = MochiKit.Base.compare; | |
593 | } | |
594 | rval.sort(cmp); | |
595 | return rval; | |
596 | }, | |
597 | ||
598 | /** @id MochiKit.Iter.reversed */ | |
599 | reversed: function (iterable) { | |
600 | var rval = MochiKit.Iter.list(iterable); | |
601 | rval.reverse(); | |
602 | return rval; | |
603 | }, | |
604 | ||
605 | /** @id MochiKit.Iter.some */ | |
606 | some: function (iterable, func) { | |
607 | var self = MochiKit.Iter; | |
608 | try { | |
609 | self.ifilter(func, iterable).next(); | |
610 | return true; | |
611 | } catch (e) { | |
612 | if (e != self.StopIteration) { | |
613 | throw e; | |
614 | } | |
615 | return false; | |
616 | } | |
617 | }, | |
618 | ||
619 | /** @id MochiKit.Iter.iextend */ | |
620 | iextend: function (lst, iterable) { | |
621 | if (MochiKit.Base.isArrayLike(iterable)) { | |
622 | // fast-path for array-like | |
623 | for (var i = 0; i < iterable.length; i++) { | |
624 | lst.push(iterable[i]); | |
625 | } | |
626 | } else { | |
627 | var self = MochiKit.Iter; | |
628 | iterable = self.iter(iterable); | |
629 | try { | |
630 | while (true) { | |
631 | lst.push(iterable.next()); | |
632 | } | |
633 | } catch (e) { | |
634 | if (e != self.StopIteration) { | |
635 | throw e; | |
636 | } | |
637 | } | |
638 | } | |
639 | return lst; | |
640 | }, | |
641 | ||
642 | /** @id MochiKit.Iter.groupby */ | |
643 | groupby: function(iterable, /* optional */ keyfunc) { | |
644 | var m = MochiKit.Base; | |
645 | var self = MochiKit.Iter; | |
646 | if (arguments.length < 2) { | |
647 | keyfunc = m.operator.identity; | |
648 | } | |
649 | iterable = self.iter(iterable); | |
650 | ||
651 | // shared | |
652 | var pk = undefined; | |
653 | var k = undefined; | |
654 | var v; | |
655 | ||
656 | function fetch() { | |
657 | v = iterable.next(); | |
658 | k = keyfunc(v); | |
659 | }; | |
660 | ||
661 | function eat() { | |
662 | var ret = v; | |
663 | v = undefined; | |
664 | return ret; | |
665 | }; | |
666 | ||
667 | var first = true; | |
668 | var compare = m.compare; | |
669 | return { | |
670 | repr: function () { return "groupby(...)"; }, | |
671 | next: function() { | |
672 | // iterator-next | |
673 | ||
674 | // iterate until meet next group | |
675 | while (compare(k, pk) === 0) { | |
676 | fetch(); | |
677 | if (first) { | |
678 | first = false; | |
679 | break; | |
680 | } | |
681 | } | |
682 | pk = k; | |
683 | return [k, { | |
684 | next: function() { | |
685 | // subiterator-next | |
686 | if (v == undefined) { // Is there something to eat? | |
687 | fetch(); | |
688 | } | |
689 | if (compare(k, pk) !== 0) { | |
690 | throw self.StopIteration; | |
691 | } | |
692 | return eat(); | |
693 | } | |
694 | }]; | |
695 | } | |
696 | }; | |
697 | }, | |
698 | ||
699 | /** @id MochiKit.Iter.groupby_as_array */ | |
700 | groupby_as_array: function (iterable, /* optional */ keyfunc) { | |
701 | var m = MochiKit.Base; | |
702 | var self = MochiKit.Iter; | |
703 | if (arguments.length < 2) { | |
704 | keyfunc = m.operator.identity; | |
705 | } | |
706 | ||
707 | iterable = self.iter(iterable); | |
708 | var result = []; | |
709 | var first = true; | |
710 | var prev_key; | |
711 | var compare = m.compare; | |
712 | while (true) { | |
713 | try { | |
714 | var value = iterable.next(); | |
715 | var key = keyfunc(value); | |
716 | } catch (e) { | |
717 | if (e == self.StopIteration) { | |
718 | break; | |
719 | } | |
720 | throw e; | |
721 | } | |
722 | if (first || compare(key, prev_key) !== 0) { | |
723 | var values = []; | |
724 | result.push([key, values]); | |
725 | } | |
726 | values.push(value); | |
727 | first = false; | |
728 | prev_key = key; | |
729 | } | |
730 | return result; | |
731 | }, | |
732 | ||
733 | /** @id MochiKit.Iter.arrayLikeIter */ | |
734 | arrayLikeIter: function (iterable) { | |
735 | var i = 0; | |
736 | return { | |
737 | repr: function () { return "arrayLikeIter(...)"; }, | |
738 | toString: MochiKit.Base.forwardCall("repr"), | |
739 | next: function () { | |
740 | if (i >= iterable.length) { | |
741 | throw MochiKit.Iter.StopIteration; | |
742 | } | |
743 | return iterable[i++]; | |
744 | } | |
745 | }; | |
746 | }, | |
747 | ||
748 | /** @id MochiKit.Iter.hasIterateNext */ | |
749 | hasIterateNext: function (iterable) { | |
750 | return (iterable && typeof(iterable.iterateNext) == "function"); | |
751 | }, | |
752 | ||
753 | /** @id MochiKit.Iter.iterateNextIter */ | |
754 | iterateNextIter: function (iterable) { | |
755 | return { | |
756 | repr: function () { return "iterateNextIter(...)"; }, | |
757 | toString: MochiKit.Base.forwardCall("repr"), | |
758 | next: function () { | |
759 | var rval = iterable.iterateNext(); | |
760 | if (rval === null || rval === undefined) { | |
761 | throw MochiKit.Iter.StopIteration; | |
762 | } | |
763 | return rval; | |
764 | } | |
765 | }; | |
766 | } | |
767 | }); | |
768 | ||
769 | ||
770 | MochiKit.Iter.EXPORT_OK = [ | |
771 | "iteratorRegistry", | |
772 | "arrayLikeIter", | |
773 | "hasIterateNext", | |
64c7f18b | 774 | "iterateNextIter" |
6a1aa64f DV |
775 | ]; |
776 | ||
777 | MochiKit.Iter.EXPORT = [ | |
778 | "StopIteration", | |
779 | "registerIteratorFactory", | |
780 | "iter", | |
781 | "count", | |
782 | "cycle", | |
783 | "repeat", | |
784 | "next", | |
785 | "izip", | |
786 | "ifilter", | |
787 | "ifilterfalse", | |
788 | "islice", | |
789 | "imap", | |
790 | "applymap", | |
791 | "chain", | |
792 | "takewhile", | |
793 | "dropwhile", | |
794 | "tee", | |
795 | "list", | |
796 | "reduce", | |
797 | "range", | |
798 | "sum", | |
799 | "exhaust", | |
800 | "forEach", | |
801 | "every", | |
802 | "sorted", | |
803 | "reversed", | |
804 | "some", | |
805 | "iextend", | |
806 | "groupby", | |
807 | "groupby_as_array" | |
808 | ]; | |
809 | ||
810 | MochiKit.Iter.__new__ = function () { | |
811 | var m = MochiKit.Base; | |
812 | // Re-use StopIteration if exists (e.g. SpiderMonkey) | |
813 | if (typeof(StopIteration) != "undefined") { | |
814 | this.StopIteration = StopIteration; | |
815 | } else { | |
816 | /** @id MochiKit.Iter.StopIteration */ | |
817 | this.StopIteration = new m.NamedError("StopIteration"); | |
818 | } | |
819 | this.iteratorRegistry = new m.AdapterRegistry(); | |
820 | // Register the iterator factory for arrays | |
821 | this.registerIteratorFactory( | |
822 | "arrayLike", | |
823 | m.isArrayLike, | |
824 | this.arrayLikeIter | |
825 | ); | |
826 | ||
827 | this.registerIteratorFactory( | |
828 | "iterateNext", | |
829 | this.hasIterateNext, | |
830 | this.iterateNextIter | |
831 | ); | |
832 | ||
833 | this.EXPORT_TAGS = { | |
834 | ":common": this.EXPORT, | |
835 | ":all": m.concat(this.EXPORT, this.EXPORT_OK) | |
836 | }; | |
837 | ||
838 | m.nameFunctions(this); | |
839 | ||
840 | }; | |
841 | ||
842 | MochiKit.Iter.__new__(); | |
843 | ||
844 | // | |
845 | // XXX: Internet Explorer blows | |
846 | // | |
847 | if (MochiKit.__export__) { | |
848 | reduce = MochiKit.Iter.reduce; | |
849 | } | |
850 | ||
851 | MochiKit.Base._exportSymbols(this, MochiKit.Iter); |