Permalink
Sep 5, 2014
Aug 24, 2015
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
Nov 4, 2015
Jan 18, 2015
Sep 5, 2014
Sep 5, 2014
Apr 26, 2015
Apr 26, 2015
Mar 28, 2015
Mar 28, 2015
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Nov 4, 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
663 lines (570 sloc)
18.1 KB
1
;(function($B){
2
5
var $ObjectDict = _b_.object.$dict,
6
str_hash = _b_.str.$dict.__hash__,
7
$N = _b_.None
8
9
// dictionary
10
function $DictClass($keys,$values){
11
this.iter = null
12
this.__class__ = $DictDict
15
var setitem=$DictDict.__setitem__
16
var i=$keys.length
17
while(i--) setitem($keys[i], $values[i])
20
var $DictDict = {__class__:$B.$type,
21
__name__ : 'dict',
24
}
25
26
var $key_iterator = function(d) {
27
this.d = d
28
this.current = 0
29
this.iter = new $item_generator(d)
30
}
32
$key_iterator.prototype.next = function() { return this.iter.next()[0] }
33
34
var $value_iterator = function(d) {
35
this.d = d
36
this.current = 0
37
this.iter = new $item_generator(d)
38
}
40
$value_iterator.prototype.next = function() { return this.iter.next()[1] }
41
42
var $item_generator = function(d) {
48
for(var attr in d.$jsobj){
49
if(attr.charAt(0)!='$'){this.items.push([attr,d.$jsobj[attr]])}
50
}
65
for (var k in d.$object_dict) {
66
var i=d.$object_dict[k].length
67
while(i--) items[pos++]=d.$object_dict[k][i]
77
}
78
throw _b_.StopIteration("StopIteration")
79
}
80
$item_generator.prototype.as_list = function() {
82
}
83
84
var $item_iterator = function(d) {
85
this.d = d
86
this.current = 0
87
this.iter = new $item_generator(d)
88
}
90
$item_iterator.prototype.next = function() { return _b_.tuple(this.iter.next()) }
91
92
var $copy_dict = function(left, right) {
97
}
98
99
$iterator_wrapper = function(items,klass){
100
var res = {
101
__class__:klass,
104
__next__:function(){
105
//if (items.length() !== items.iter.used) {
106
// throw _b_.RuntimeError("dictionary changed size during iteration")
107
//}
108
return items.next()
109
//return items[counter++]
110
},
111
//__repr__:function(){return "<"+klass.__name__+" object>"},
112
__repr__:function(){return klass.__name__+'('+ new $item_generator(items).as_list().join(',') + ')'},
120
var $dict_keysDict = $B.$iterator_class('dict_keys')
121
122
$DictDict.keys = function(self){
123
if (arguments.length > 1) {
124
var _len=arguments.length - 1
125
var _msg="keys() takes no arguments ("+_len+" given)"
126
throw _b_.TypeError(_msg)
127
}
128
return $iterator_wrapper(new $key_iterator(self),$dict_keysDict)
129
}
130
131
var $dict_valuesDict = $B.$iterator_class('dict_values')
132
133
$DictDict.values = function(self){
134
if (arguments.length > 1) {
135
var _len=arguments.length - 1
136
var _msg="values() takes no arguments ("+_len+" given)"
137
throw _b_.TypeError(_msg)
138
}
143
144
$DictDict.__contains__ = function(self,item){
145
if(self.$jsobj) return self.$jsobj[item]!==undefined
146
switch(typeof item) {
147
case 'string':
148
return self.$string_dict[item] !==undefined
154
if (self.$str_hash[_key]!==undefined &&
155
_b_.getattr(item,'__eq__')(self.$str_hash[_key])){return true}
156
if (self.$numeric_dict[_key]!==undefined &&
157
_b_.getattr(item,'__eq__')(_key)){return true}
158
if (self.$object_dict[_key] !== undefined) {
159
var _eq = getattr(item, '__eq__')
160
var i=self.$object_dict[_key].length
161
while(i--) {
162
if (_eq(self.$object_dict[_key][i][0])) return true
163
}
164
}
165
return false
166
}
167
168
$DictDict.__delitem__ = function(self,arg){
169
if(self.$jsobj){
170
if(self.$jsobj[arg]===undefined){throw KeyError(arg)}
171
delete self.$jsobj[arg]
174
switch(typeof arg) {
175
case 'string':
176
if (self.$string_dict[arg] === undefined) throw KeyError(_b_.str(arg))
177
delete self.$string_dict[arg]
180
case 'number':
181
if (self.$numeric_dict[arg] === undefined) throw KeyError(_b_.str(arg))
182
delete self.$numeric_dict[arg]
187
var _key=hash(arg)
188
if (self.$object_dict[_key] !== undefined) {
189
var _eq=getattr(arg, '__eq__')
190
var i=self.$object_dict[_key].length
191
while(i--) {
192
if (_eq(self.$object_dict[_key][i][0])) {
193
delete self.$object_dict[_key][i];
194
break;
195
}
196
}
197
}
201
}
202
203
$DictDict.__eq__ = function(self,other){
204
if(other===undefined){ // compare self to class "dict"
205
return self===dict
206
}
222
}
223
224
$DictDict.__getitem__ = function(self,arg){
225
226
if(self.$jsobj){
227
if(self.$jsobj[arg]===undefined){return None}
228
return self.$jsobj[arg]
229
}
230
231
switch(typeof arg) {
232
case 'string':
233
if (self.$string_dict[arg] !== undefined) return self.$string_dict[arg]
234
break
235
case 'number':
236
if (self.$numeric_dict[arg] !== undefined) return self.$numeric_dict[arg]
242
var sk = self.$str_hash[_key]
243
if (sk!==undefined && _b_.getattr(arg,'__eq__')(sk)){
244
return self.$string_dict[sk]
245
}
246
if (self.$numeric_dict[_key]!==undefined &&
247
_b_.getattr(arg,'__eq__')(_key)){
248
return self.$numeric_dict[_key]
249
}
250
if (self.$object_dict[_key] !== undefined) {
251
var _eq=getattr(arg, '__eq__')
252
var i=self.$object_dict[_key].length
253
while(i--) {
254
if (_eq(self.$object_dict[_key][i][0])) {
255
return self.$object_dict[_key][i][1]
256
}
257
}
258
}
262
throw KeyError(_b_.str(arg))
263
}
264
265
$DictDict.__hash__ = function(self) {
266
if (self === undefined) {
267
return $DictDict.__hashvalue__ || $B.$py_next_hash-- // for hash of dict type (not instance of dict)
268
}
269
throw _b_.TypeError("unhashable type: 'dict'");
270
}
271
272
$DictDict.__init__ = function(self){
273
var args = [], pos=0
274
for(var i=1;i<arguments.length;i++){args[pos++]=arguments[i]}
281
var obj = args[0]
290
}
292
if(obj.__class__===$B.JSObject.$dict){
293
// convert a JSObject into a Python dictionary
294
var si = $DictDict.__setitem__
295
for(var attr in obj.js) si(self,attr,obj.js[attr])
296
297
// Attribute $jsobj is used to update the original JS object
298
// when the dictionary is modified
301
}
305
var args = $ns['args']
306
var kw = $ns['kw']
309
if(isinstance(args[0],dict)){
312
}
314
// format dict([(k1,v1),(k2,v2)...])
321
}else{
322
var iterable = iter(args[0])
323
while(1){
324
try{
325
var elt = next(iterable)
326
var key = getattr(elt,'__getitem__')(0)
327
var value = getattr(elt,'__getitem__')(1)
328
$DictDict.__setitem__(self, key, value)
329
}catch(err){
333
}
334
}
338
}
339
340
var $dict_iterator = $B.$iterator_class('dict iterator')
343
}
344
353
for (var k in self.$numeric_dict) _count++
354
for (var k in self.$string_dict) _count++
355
for (var k in self.$object_dict) _count+= self.$object_dict[k].length
359
360
$DictDict.__mro__ = [$DictDict,$ObjectDict]
361
362
$DictDict.__ne__ = function(self,other){return !$DictDict.__eq__(self,other)}
363
364
$DictDict.__next__ = function(self){
372
}
373
}
374
375
$DictDict.__repr__ = function(self){
376
if(self===undefined) return "<class 'dict'>"
377
if(self.$jsobj){ // wrapper around Javascript object
378
var res = []
379
for(var attr in self.$jsobj){
380
if(attr.charAt(0)=='$' || attr=='__class__'){continue}
381
else{
382
try{
383
res.push("'"+attr+"': "+_b_.repr(self.$jsobj[attr]))
384
}catch(err){
385
// FIX ME
386
}
387
}
396
if (_objs.indexOf(itm[1]) > -1 && _b_.isinstance(itm[1], [_b_.dict,_b_.list,_b_.set, _b_.tuple])) {
404
}
406
}
407
408
$DictDict.__setitem__ = function(self,key,value){
425
var _eq=getattr(key, '__eq__')
426
427
if(self.$numeric_dict[_key]!==undefined && _eq(_key)){
428
self.$numeric_dict[_key] = value
430
}
431
var sk = self.$str_hash[_key]
432
if(sk!==undefined && _eq(sk)){
433
self.$string_dict[sk] = value
438
if (self.$object_dict[_key] != undefined) {
439
var i=self.$object_dict[_key].length
440
while(i--) {
441
if (_eq(self.$object_dict[_key][i][0])) {
442
self.$object_dict[_key][i]=[key, value]
444
}
445
}
446
// if we got here this key is not in the object
447
self.$object_dict[_key].push([key, value])
448
} else {
449
self.$object_dict[_key]=[[key, value]]
452
}
453
454
$DictDict.__str__ = $DictDict.__repr__
455
456
// add "reflected" methods
457
$B.make_rmethods($DictDict)
458
459
$DictDict.clear = function(self){
460
// Remove all items from the dictionary.
467
if(self.$jsobj) self.$jsobj={}
469
}
470
471
$DictDict.copy = function(self){
472
// Return a shallow copy of the dictionary
475
return res
476
}
477
479
try{return $DictDict.__getitem__(self, key)}
480
catch(err){
481
if(_b_.isinstance(err, _b_.KeyError)){
482
return _default === undefined ? None : _default
483
}else{throw err}
484
}
485
}
486
488
489
$DictDict.items = function(self){
490
if (arguments.length > 1) {
491
var _len=arguments.length - 1
492
var _msg="items() takes no arguments ("+_len+" given)"
493
throw _b_.TypeError(_msg)
494
}
496
}
497
499
// class method
501
var res = dict()
502
var keys_iter = _b_.iter(keys)
503
while(1){
504
try{
505
var key = _b_.next(keys_iter)
506
$DictDict.__setitem__(res,key,value)
507
}catch(err){
508
if($B.is_exc(err,[_b_.StopIteration])){
509
return res
510
}
511
throw err
512
}
513
}
514
}
515
516
$DictDict.pop = function(self,key,_default){
517
try{
518
var res = $DictDict.__getitem__(self,key)
519
$DictDict.__delitem__(self,key)
520
return res
521
}catch(err){
522
if(err.__name__==='KeyError'){
523
if(_default!==undefined) return _default
524
throw err
525
}
526
throw err
527
}
528
}
529
530
$DictDict.popitem = function(self){
531
try{
532
var itm = new $item_iterator(self).next()
533
$DictDict.__delitem__(self,itm[0])
534
return _b_.tuple(itm)
535
}catch(err) {
536
if (err.__name__ == "StopIteration") {
537
throw KeyError("'popitem(): dictionary is empty'")
538
}
539
}
540
}
541
542
$DictDict.setdefault = function(self,key,_default){
543
try{return $DictDict.__getitem__(self,key)}
544
catch(err){
545
if(_default===undefined) _default=None
546
$DictDict.__setitem__(self,key,_default)
547
return _default
548
}
549
}
550
551
$DictDict.update = function(self){
552
var params = [], pos=0
553
for(var i=1;i<arguments.length;i++){params[pos++]=arguments[i]}
555
var args = $ns['args']
556
if(args.length>0) {
557
var o=args[0]
558
if (isinstance(o,dict)){
559
$copy_dict(self, o)
560
} else if (hasattr(o, '__getitem__') && hasattr(o, 'keys')) {
561
var _keys=_b_.list(getattr(o, 'keys')())
562
var si=$DictDict.__setitem__
563
var i=_keys.length
564
while(i--) {
565
//for (var i=0; i < _keys.length; i++) {
566
var _value = getattr(o, '__getitem__')(_keys[i])
567
si(self, _keys[i], _value)
570
}
571
var kw = $ns['kw']
574
}
575
590
var item=args[i]
591
switch(typeof item[0]) {
592
case 'string':
593
res.$string_dict[item[0]]=item[1]
595
break;
596
case 'number':
597
res.$numeric_dict[item[0]]=item[1]
598
break
599
default:
600
si(res, item[0], item[1])
607
// apply __init__ with arguments of dict()
610
var _args = [res], pos=1
611
for(var i=0, _len_i = arguments.length; i < _len_i;i++){_args[pos++]=arguments[i]}
613
return res
614
}
616
dict.__class__ = $B.$factory
617
dict.$dict = $DictDict
618
$DictDict.$factory = dict
619
$DictDict.__new__ = $B.$__new__(dict)
620
621
_b_.dict = dict
623
// following are used for faster access elsewhere
624
$B.$dict_iterator = function(d) { return new $item_generator(d) }
625
$B.$dict_length = $DictDict.__len__
626
$B.$dict_getitem = $DictDict.__getitem__
627
$B.$dict_get = $DictDict.get
628
$B.$dict_set = $DictDict.__setitem__
629
$B.$dict_contains = $DictDict.__contains__
630
$B.$dict_items = function(d) { return new $item_generator(d).as_list() }
631
$B.$copy_dict = $copy_dict // copy from right to left
632
$B.$dict_get_copy = $DictDict.copy // return a shallow copy
633
635
// Class for attribute __dict__ of classes
636
var mappingproxyDict = {
637
__class__ : $B.$type,
638
__name__ : "mappingproxy"
639
}
640
mappingproxyDict.__mro__ = [mappingproxyDict, _b_.object.$dict]
641
642
mappingproxyDict.__setitem__ = function(){
643
throw _b_.TypeError("'mappingproxy' object does not support item assignment")
644
}
645
647
function mappingproxy(obj){
648
var res = obj_dict(obj)
649
res.__class__ = mappingproxyDict
650
return res
651
}
652
mappingproxy.__class__ = $B.$factory
653
mappingproxy.$dict = mappingproxyDict
654
mappingproxyDict.$factory = mappingproxy
655
$B.mappingproxy = mappingproxy
656
657
$B.obj_dict = function(obj){
658
var res = dict()
659
res.$jsobj = obj
660
return res
661
}
662
663
})(__BRYTHON__)