Permalink
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 28, 2015
Sep 5, 2014
Sep 5, 2014
Dec 31, 2014
Dec 31, 2014
Dec 31, 2014
May 19, 2015
Mar 28, 2015
Dec 31, 2014
Dec 31, 2014
Dec 31, 2014
Dec 31, 2014
Mar 25, 2015
May 30, 2015
Dec 31, 2014
Jan 9, 2015
Dec 31, 2014
Jan 9, 2015
Sep 5, 2014
Jan 1, 2015
Apr 26, 2015
Mar 28, 2015
Sep 5, 2014
May 12, 2015
Jan 1, 2015
Jan 3, 2015
Mar 28, 2015
Sep 5, 2014
Sep 5, 2014
May 12, 2015
Jan 1, 2015
Jan 3, 2015
Apr 26, 2015
Mar 28, 2015
Sep 5, 2014
Dec 31, 2014
Sep 5, 2014
Apr 12, 2015
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 28, 2015
Jan 18, 2015
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 1, 2015
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 28, 2015
Sep 5, 2014
Sep 5, 2014
May 12, 2015
Jan 18, 2015
Sep 5, 2014
Sep 5, 2014
Apr 26, 2015
Mar 28, 2015
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Jan 1, 2015
Sep 5, 2014
Mar 28, 2015
Sep 5, 2014
Sep 5, 2014
Jan 9, 2015
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Dec 31, 2014
Sep 5, 2014
Apr 12, 2015
Sep 5, 2014
Jan 19, 2015
Apr 12, 2015
Sep 5, 2014
Sep 5, 2014
Mar 28, 2015
Mar 28, 2015
Sep 5, 2014
Apr 12, 2015
Sep 5, 2014
Sep 5, 2014
Dec 31, 2014
May 11, 2015
May 11, 2015
May 12, 2015
Sep 5, 2014
Newer
100644
666 lines (570 sloc)
18.2 KB
1
;(function($B){
2
5
var $ObjectDict = _b_.object.$dict
7
8
// dictionary
9
function $DictClass($keys,$values){
10
this.iter = null
11
this.__class__ = $DictDict
14
var setitem=$DictDict.__setitem__
15
var i=$keys.length
16
while(i--) setitem($keys[i], $values[i])
19
var $DictDict = {__class__:$B.$type,
20
__name__ : 'dict',
23
}
24
25
var $key_iterator = function(d) {
26
this.d = d
27
this.current = 0
28
this.iter = new $item_generator(d)
29
}
31
$key_iterator.prototype.next = function() { return this.iter.next()[0] }
32
33
var $value_iterator = function(d) {
34
this.d = d
35
this.current = 0
36
this.iter = new $item_generator(d)
37
}
39
$value_iterator.prototype.next = function() { return this.iter.next()[1] }
40
41
var $item_generator = function(d) {
47
for(var attr in d.$jsobj){
48
if(attr.charAt(0)!='$'){this.items.push([attr,d.$jsobj[attr]])}
49
}
64
for (var k in d.$object_dict) {
65
var i=d.$object_dict[k].length
66
while(i--) items[pos++]=d.$object_dict[k][i]
76
}
77
throw _b_.StopIteration("StopIteration")
78
}
79
$item_generator.prototype.as_list = function() {
81
}
82
83
var $item_iterator = function(d) {
84
this.d = d
85
this.current = 0
86
this.iter = new $item_generator(d)
87
}
89
$item_iterator.prototype.next = function() { return _b_.tuple(this.iter.next()) }
90
91
var $copy_dict = function(left, right) {
96
}
97
98
$iterator_wrapper = function(items,klass){
99
var res = {
100
__class__:klass,
103
__next__:function(){
104
//if (items.length() !== items.iter.used) {
105
// throw _b_.RuntimeError("dictionary changed size during iteration")
106
//}
107
return items.next()
108
//return items[counter++]
109
},
110
//__repr__:function(){return "<"+klass.__name__+" object>"},
111
__repr__:function(){return klass.__name__+'('+ new $item_generator(items).as_list().join(',') + ')'},
119
var $dict_keysDict = $B.$iterator_class('dict_keys')
120
121
$DictDict.keys = function(self){
122
if (arguments.length > 1) {
123
var _len=arguments.length - 1
124
var _msg="keys() takes no arguments ("+_len+" given)"
125
throw _b_.TypeError(_msg)
126
}
127
return $iterator_wrapper(new $key_iterator(self),$dict_keysDict)
128
}
129
130
var $dict_valuesDict = $B.$iterator_class('dict_values')
131
132
$DictDict.values = function(self){
133
if (arguments.length > 1) {
134
var _len=arguments.length - 1
135
var _msg="values() takes no arguments ("+_len+" given)"
136
throw _b_.TypeError(_msg)
137
}
142
143
$DictDict.__contains__ = function(self,item){
144
if(self.$jsobj) return self.$jsobj[item]!==undefined
145
switch(typeof item) {
146
case 'string':
147
return self.$string_dict[item] !==undefined
153
if (self.$str_hash[_key]!==undefined &&
154
_b_.getattr(item,'__eq__')(self.$str_hash[_key])){return true}
155
if (self.$numeric_dict[_key]!==undefined &&
156
_b_.getattr(item,'__eq__')(_key)){return true}
157
if (self.$object_dict[_key] !== undefined) {
158
var _eq = getattr(item, '__eq__')
159
var i=self.$object_dict[_key].length
160
while(i--) {
161
if (_eq(self.$object_dict[_key][i][0])) return true
162
}
163
}
164
return false
165
}
166
167
$DictDict.__delitem__ = function(self,arg){
168
if(self.$jsobj){
169
if(self.$jsobj[arg]===undefined){throw KeyError(arg)}
170
delete self.$jsobj[arg]
171
return
172
}
173
switch(typeof arg) {
174
case 'string':
175
if (self.$string_dict[arg] === undefined) throw KeyError(_b_.str(arg))
176
delete self.$string_dict[arg]
179
case 'number':
180
if (self.$numeric_dict[arg] === undefined) throw KeyError(_b_.str(arg))
181
delete self.$numeric_dict[arg]
182
return
186
var _key=hash(arg)
187
if (self.$object_dict[_key] !== undefined) {
188
var _eq=getattr(arg, '__eq__')
189
var i=self.$object_dict[_key].length
190
while(i--) {
191
if (_eq(self.$object_dict[_key][i][0])) {
192
delete self.$object_dict[_key][i];
193
break;
194
}
195
}
196
}
199
}
200
201
$DictDict.__eq__ = function(self,other){
202
if(other===undefined){ // compare self to class "dict"
203
return self===dict
204
}
220
}
221
222
$DictDict.__getitem__ = function(self,arg){
223
224
if(self.$jsobj){
225
if(self.$jsobj[arg]===undefined){return None}
226
return self.$jsobj[arg]
227
}
228
229
switch(typeof arg) {
230
case 'string':
231
if (self.$string_dict[arg] !== undefined) return self.$string_dict[arg]
232
break
233
case 'number':
234
if (self.$numeric_dict[arg] !== undefined) return self.$numeric_dict[arg]
240
var sk = self.$str_hash[_key]
241
if (sk!==undefined && _b_.getattr(arg,'__eq__')(sk)){
242
return self.$string_dict[sk]
243
}
244
if (self.$numeric_dict[_key]!==undefined &&
245
_b_.getattr(arg,'__eq__')(_key)){
246
return self.$numeric_dict[_key]
247
}
248
if (self.$object_dict[_key] !== undefined) {
249
var _eq=getattr(arg, '__eq__')
250
var i=self.$object_dict[_key].length
251
while(i--) {
252
if (_eq(self.$object_dict[_key][i][0])) {
253
return self.$object_dict[_key][i][1]
254
}
255
}
256
}
260
throw KeyError(_b_.str(arg))
261
}
262
263
$DictDict.__hash__ = function(self) {
264
if (self === undefined) {
265
return $DictDict.__hashvalue__ || $B.$py_next_hash-- // for hash of dict type (not instance of dict)
266
}
267
throw _b_.TypeError("unhashable type: 'dict'");
268
}
269
270
$DictDict.__init__ = function(self){
271
var args = [], pos=0
272
for(var i=1;i<arguments.length;i++){args[pos++]=arguments[i]}
279
var obj = args[0]
287
return
288
}
290
if(obj.__class__===$B.JSObject.$dict){
291
// convert a JSObject into a Python dictionary
292
var si = $DictDict.__setitem__
293
for(var attr in obj.js) si(self,attr,obj.js[attr])
294
295
// Attribute $jsobj is used to update the original JS object
296
// when the dictionary is modified
298
return
299
}
303
var args = $ns['args']
304
var kw = $ns['kw']
307
if(isinstance(args[0],dict)){
309
return
310
}
312
// format dict([(k1,v1),(k2,v2)...])
319
}else{
320
var iterable = iter(args[0])
321
while(1){
322
try{
323
var elt = next(iterable)
324
var key = getattr(elt,'__getitem__')(0)
325
var value = getattr(elt,'__getitem__')(1)
326
$DictDict.__setitem__(self, key, value)
327
}catch(err){
331
}
332
}
335
}
336
337
var $dict_iterator = $B.$iterator_class('dict iterator')
340
}
341
350
for (var k in self.$numeric_dict) _count++
351
for (var k in self.$string_dict) _count++
352
for (var k in self.$object_dict) _count+= self.$object_dict[k].length
356
357
$DictDict.__mro__ = [$DictDict,$ObjectDict]
358
359
$DictDict.__ne__ = function(self,other){return !$DictDict.__eq__(self,other)}
360
361
$DictDict.__next__ = function(self){
369
}
370
}
371
372
$DictDict.__repr__ = function(self){
373
if(self===undefined) return "<class 'dict'>"
374
if(self.$jsobj){ // wrapper around Javascript object
375
var res = []
376
for(var attr in self.$jsobj){
377
if(attr.charAt(0)=='$' || attr=='__class__'){continue}
387
if (_objs.indexOf(itm[1]) > -1 && _b_.isinstance(itm[1], [_b_.dict,_b_.list,_b_.set, _b_.tuple])) {
395
}
397
}
398
399
$DictDict.__setitem__ = function(self,key,value){
416
var _eq=getattr(key, '__eq__')
417
418
if(self.$numeric_dict[_key]!==undefined && _eq(_key)){
419
self.$numeric_dict[_key] = value
420
return
421
}
422
var sk = self.$str_hash[_key]
423
if(sk!==undefined && _eq(sk)){
424
self.$string_dict[sk] = value
425
return
426
}
427
428
429
if (self.$object_dict[_key] != undefined) {
430
var i=self.$object_dict[_key].length
431
while(i--) {
432
if (_eq(self.$object_dict[_key][i][0])) {
433
self.$object_dict[_key][i]=[key, value]
434
return
435
}
436
}
437
// if we got here this key is not in the object
438
self.$object_dict[_key].push([key, value])
439
} else {
440
self.$object_dict[_key]=[[key, value]]
443
}
444
445
$DictDict.__str__ = $DictDict.__repr__
446
447
// add "reflected" methods
448
$B.make_rmethods($DictDict)
449
450
$DictDict.clear = function(self){
451
// Remove all items from the dictionary.
458
if(self.$jsobj) self.$jsobj={}
459
}
460
461
$DictDict.copy = function(self){
462
// Return a shallow copy of the dictionary
465
return res
466
}
467
469
if (_default === undefined) _default=None
470
switch(typeof key) {
471
case 'string':
472
return self.$string_dict[key] || _default
475
}
477
var _key=hash(key)
478
if (self.$object_dict[_key] != undefined) {
479
var _eq=getattr(key, '__eq__')
480
var i=self.$object_dict[_key].length
481
while(i--) {
482
if (_eq(self.$object_dict[_key][i][0]))
483
return self.$object_dict[_key][i][1]
484
}
485
}
486
489
}
490
492
493
$DictDict.items = function(self){
494
if (arguments.length > 1) {
495
var _len=arguments.length - 1
496
var _msg="items() takes no arguments ("+_len+" given)"
497
throw _b_.TypeError(_msg)
498
}
500
}
501
503
// class method
505
var res = dict()
506
var keys_iter = _b_.iter(keys)
507
while(1){
508
try{
509
var key = _b_.next(keys_iter)
510
$DictDict.__setitem__(res,key,value)
511
}catch(err){
512
if($B.is_exc(err,[_b_.StopIteration])){
513
return res
514
}
515
throw err
516
}
517
}
518
}
519
520
$DictDict.pop = function(self,key,_default){
521
try{
522
var res = $DictDict.__getitem__(self,key)
523
$DictDict.__delitem__(self,key)
524
return res
525
}catch(err){
526
if(err.__name__==='KeyError'){
527
if(_default!==undefined) return _default
528
throw err
529
}
530
throw err
531
}
532
}
533
534
$DictDict.popitem = function(self){
535
try{
536
var itm = new $item_iterator(self).next()
537
$DictDict.__delitem__(self,itm[0])
538
return _b_.tuple(itm)
539
}catch(err) {
540
if (err.__name__ == "StopIteration") {
541
throw KeyError("'popitem(): dictionary is empty'")
542
}
543
}
544
}
545
546
$DictDict.setdefault = function(self,key,_default){
547
try{return $DictDict.__getitem__(self,key)}
548
catch(err){
549
if(_default===undefined) _default=None
550
$DictDict.__setitem__(self,key,_default)
551
return _default
552
}
553
}
554
555
$DictDict.update = function(self){
556
var params = [], pos=0
557
for(var i=1;i<arguments.length;i++){params[pos++]=arguments[i]}
559
var args = $ns['args']
560
if(args.length>0) {
561
var o=args[0]
562
if (isinstance(o,dict)){
563
$copy_dict(self, o)
564
} else if (hasattr(o, '__getitem__') && hasattr(o, 'keys')) {
565
var _keys=_b_.list(getattr(o, 'keys')())
566
var si=$DictDict.__setitem__
567
var i=_keys.length
568
while(i--) {
569
//for (var i=0; i < _keys.length; i++) {
570
var _value = getattr(o, '__getitem__')(_keys[i])
571
si(self, _keys[i], _value)
574
}
575
var kw = $ns['kw']
577
}
578
593
var item=args[i]
594
switch(typeof item[0]) {
595
case 'string':
596
res.$string_dict[item[0]]=item[1]
598
break;
599
case 'number':
600
res.$numeric_dict[item[0]]=item[1]
601
break
602
default:
603
si(res, item[0], item[1])
610
// apply __init__ with arguments of dict()
613
var _args = [res], pos=1
614
for(var i=0, _len_i = arguments.length; i < _len_i;i++){_args[pos++]=arguments[i]}
616
return res
617
}
619
dict.__class__ = $B.$factory
620
dict.$dict = $DictDict
621
$DictDict.$factory = dict
622
$DictDict.__new__ = $B.$__new__(dict)
623
624
_b_.dict = dict
626
// following are used for faster access elsewhere
627
$B.$dict_iterator = function(d) { return new $item_generator(d) }
628
$B.$dict_length = $DictDict.__len__
629
$B.$dict_getitem = $DictDict.__getitem__
630
$B.$dict_get = $DictDict.get
631
$B.$dict_set = $DictDict.__setitem__
632
$B.$dict_contains = $DictDict.__contains__
633
$B.$dict_items = function(d) { return new $item_generator(d).as_list() }
634
$B.$copy_dict = $copy_dict // copy from right to left
635
$B.$dict_get_copy = $DictDict.copy // return a shallow copy
636
638
// Class for attribute __dict__ of classes
639
var mappingproxyDict = {
640
__class__ : $B.$type,
641
__name__ : "mappingproxy"
642
}
643
mappingproxyDict.__mro__ = [mappingproxyDict, _b_.object.$dict]
644
645
mappingproxyDict.__setitem__ = function(){
646
throw _b_.TypeError("'mappingproxy' object does not support item assignment")
647
}
648
650
function mappingproxy(obj){
651
var res = obj_dict(obj)
652
res.__class__ = mappingproxyDict
653
return res
654
}
655
mappingproxy.__class__ = $B.$factory
656
mappingproxy.$dict = mappingproxyDict
657
mappingproxyDict.$factory = mappingproxy
658
$B.mappingproxy = mappingproxy
659
660
$B.obj_dict = function(obj){
661
var res = dict()
662
res.$jsobj = obj
663
return res
664
}
665
666
})(__BRYTHON__)