def values(self, w_dict): return [unwrap_cell(self.space, w_value) for w_value in self.unerase(w_dict.dstorage).dict_w.itervalues()] def items(self, w_dict): space = self.space return [space.newtuple([space.wrap(key), unwrap_cell(self.space, w_value)]) for (key, w_value) in self.unerase(w_dict.dstorage).dict_w.iteritems()] def clear(self, w_dict): space = self.space w_type = self.unerase(w_dict.dstorage) if not w_type.is_heaptype(): raise oefmt(space.w_TypeError, "can't clear dictionary of type '%N'", w_type) w_type.dict_w.clear() w_type.mutated(None) def getiterkeys(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.iterkeys() def getitervalues(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.itervalues() def getiteritems(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.iteritems() def wrapkey(space, key): return space.wrap(key) def wrapvalue(space, value): return unwrap_cell(space, value) create_iterator_classes(DictProxyStrategy)
w_dict.dstorage = storage def view_as_kwargs(self, w_dict): keys, values_w = self.unerase(w_dict.dstorage) return keys[:], values_w[:] # copy to make non-resizable def getiterkeys(self, w_dict): return iter(self.unerase(w_dict.dstorage)[0]) def getitervalues(self, w_dict): return iter(self.unerase(w_dict.dstorage)[1]) def getiteritems(self, w_dict): keys = self.unerase(w_dict.dstorage)[0] return iter(range(len(keys))) wrapkey = _wrapkey def next_item(self): strategy = self.strategy assert isinstance(strategy, KwargsDictStrategy) for i in self.iterator: keys, values_w = strategy.unerase(self.dictimplementation.dstorage) return _wrapkey(self.space, keys[i]), values_w[i] else: return None, None create_iterator_classes(KwargsDictStrategy, override_next_item=next_item)
return iter(self.unerase(w_dict.dstorage)[0]) def getitervalues(self, w_dict): return iter(self.unerase(w_dict.dstorage)[1]) def getiteritems(self, w_dict): return Zip(*self.unerase(w_dict.dstorage)) wrapkey = _wrapkey class Zip(object): def __init__(self, list1, list2): assert len(list1) == len(list2) self.list1 = list1 self.list2 = list2 self.i = 0 def __iter__(self): return self def next(self): i = self.i if i >= len(self.list1): raise StopIteration self.i = i + 1 return (self.list1[i], self.list2[i]) create_iterator_classes(KwargsDictStrategy)
def getiterkeys(self, w_dict): return iter(self.unerase(w_dict.dstorage)[0]) def getitervalues(self, w_dict): return iter(self.unerase(w_dict.dstorage)[1]) def getiteritems(self, w_dict): return Zip(*self.unerase(w_dict.dstorage)) wrapkey = _wrapkey class Zip(object): def __init__(self, list1, list2): assert len(list1) == len(list2) self.list1 = list1 self.list2 = list2 self.i = 0 def __iter__(self): return self def next(self): i = self.i if i >= len(self.list1): raise StopIteration self.i = i + 1 return (self.list1[i], self.list2[i]) create_iterator_classes(KwargsDictStrategy)
def getitervalues(self, w_dict): storage_w = self.unerase(w_dict.dstorage) return iter(storage_w) def getiteritems_with_hash(self, w_dict): storage_w = self.unerase(w_dict.dstorage) return ZipItemsWithHash(self.jsonmap.get_keys_in_order(), storage_w) class ZipItemsWithHash(object): def __init__(self, list1, list2): assert len(list1) == len(list2) self.list1 = list1 self.list2 = list2 self.i = 0 def __iter__(self): return self def next(self): i = self.i if i >= len(self.list1): raise StopIteration self.i = i + 1 w_key = self.list1[i] return (w_key, self.list2[i], w_key.hash_w()) create_iterator_classes(JsonDictStrategy)
key, cell = d.popitem() self.mutated() return _wrapkey(space, key), unwrap_cell(self.space, cell) def switch_to_object_strategy(self, w_dict): space = self.space d = self.unerase(w_dict.dstorage) strategy = space.fromcache(ObjectDictStrategy) d_new = strategy.unerase(strategy.get_empty_storage()) for key, cell in d.iteritems(): d_new[_wrapkey(space, key)] = unwrap_cell(self.space, cell) w_dict.set_strategy(strategy) w_dict.dstorage = strategy.erase(d_new) def getiterkeys(self, w_dict): return self.unerase(w_dict.dstorage).iterkeys() def getitervalues(self, w_dict): return self.unerase(w_dict.dstorage).itervalues() def getiteritems_with_hash(self, w_dict): return objectmodel.iteritems_with_hash(self.unerase(w_dict.dstorage)) wrapkey = _wrapkey def wrapvalue(space, value): return unwrap_cell(space, value) create_iterator_classes(ModuleDictStrategy)
for (key, w_value) in self.unerase(w_dict.dstorage).dict_w.iteritems() ] def clear(self, w_dict): space = self.space w_type = self.unerase(w_dict.dstorage) if not w_type.is_heaptype(): raise oefmt(space.w_TypeError, "can't clear dictionary of type '%N'", w_type) w_type.dict_w.clear() w_type.mutated(None) def getiterkeys(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.iterkeys() def getitervalues(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.itervalues() def getiteritems_with_hash(self, w_dict): return iteritems_with_hash(self.unerase(w_dict.dstorage).dict_w) def wrapkey(space, key): return space.newtext(key) def wrapvalue(space, value): return unwrap_cell(space, value) create_iterator_classes(ClassDictStrategy)
key, cell = d.popitem() self.mutated() return _wrapkey(space, key), unwrap_cell(self.space, cell) def switch_to_object_strategy(self, w_dict): space = self.space d = self.unerase(w_dict.dstorage) strategy = space.fromcache(ObjectDictStrategy) d_new = strategy.unerase(strategy.get_empty_storage()) for key, cell in d.iteritems(): d_new[_wrapkey(space, key)] = unwrap_cell(self.space, cell) w_dict.strategy = strategy w_dict.dstorage = strategy.erase(d_new) def getiterkeys(self, w_dict): return self.unerase(w_dict.dstorage).iterkeys() def getitervalues(self, w_dict): return self.unerase(w_dict.dstorage).itervalues() def getiteritems(self, w_dict): return self.unerase(w_dict.dstorage).iteritems() wrapkey = _wrapkey def wrapvalue(space, value): return unwrap_cell(space, value) create_iterator_classes(ModuleDictStrategy)
space = self.space w_type = self.unerase(w_dict.dstorage) if not w_type.is_heaptype(): raise oefmt(space.w_TypeError, "can't clear dictionary of type '%N'", w_type) w_type.dict_w.clear() w_type.mutated(None) def getiterkeys(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.iterkeys() def getitervalues(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.itervalues() def getiteritems(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.iteritems() def wrapkey(space, key): return _wrapkey(space, key) def wrapvalue(space, value): return unwrap_cell(space, value) def _wrapkey(space, key): # keys are utf-8 encoded identifiers from type's dict_w return space.wrap(key.decode('utf-8')) create_iterator_classes(DictProxyStrategy)
for i in range(len(keys)): d_new[keys[i]] = values_w[i] w_dict.strategy = strategy w_dict.dstorage = storage def view_as_kwargs(self, w_dict): keys, values_w = self.unerase(w_dict.dstorage) return keys[:], values_w[:] # copy to make non-resizable def getiterkeys(self, w_dict): return iter(self.unerase(w_dict.dstorage)[0]) def getitervalues(self, w_dict): return iter(self.unerase(w_dict.dstorage)[1]) def getiteritems(self, w_dict): keys = self.unerase(w_dict.dstorage)[0] return iter(range(len(keys))) def wrapkey(space, key): return space.wrap(key) def next_item(self): strategy = self.strategy assert isinstance(strategy, KwargsDictStrategy) for i in self.iterator: keys, values_w = strategy.unerase( self.dictimplementation.dstorage) return self.space.wrap(keys[i]), values_w[i] else: return None, None create_iterator_classes(KwargsDictStrategy, override_next_item=next_item)
def items(self, w_dict): space = self.space return [space.newtuple([space.wrap(key), unwrap_cell(self.space, w_value)]) for (key, w_value) in self.unerase(w_dict.dstorage).dict_w.iteritems()] def clear(self, w_dict): space = self.space w_type = self.unerase(w_dict.dstorage) if not w_type.is_heaptype(): raise oefmt(space.w_TypeError, "can't clear dictionary of type '%N'", w_type) w_type.dict_w.clear() w_type.mutated(None) def getiterkeys(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.iterkeys() def getitervalues(self, w_dict): return self.unerase(w_dict.dstorage).dict_w.itervalues() def getiteritems_with_hash(self, w_dict): return iteritems_with_hash(self.unerase(w_dict.dstorage).dict_w) def wrapkey(space, key): return space.wrap(key) def wrapvalue(space, value): return unwrap_cell(space, value) create_iterator_classes(ClassDictStrategy)
minimark GC we never have two live objects with the same hash, so it would never happen anyway. """ erase, unerase = rerased.new_erasing_pair("identitydict") erase = staticmethod(erase) unerase = staticmethod(unerase) def wrap(self, unwrapped): return unwrapped def unwrap(self, wrapped): return wrapped def get_empty_storage(self): d = {} mark_dict_non_null(d) return self.erase(d) def is_correct_type(self, w_obj): w_type = self.space.type(w_obj) return w_type.compares_by_identity() def _never_equal_to(self, w_lookup_type): return False def w_keys(self, w_dict): return self.space.newlist(self.unerase(w_dict.dstorage).keys()) create_iterator_classes(IdentityDictStrategy)
never happen anyway. """ erase, unerase = rerased.new_erasing_pair("identitydict") erase = staticmethod(erase) unerase = staticmethod(unerase) def wrap(self, unwrapped): return unwrapped def unwrap(self, wrapped): return wrapped def get_empty_storage(self): d = {} mark_dict_non_null(d) return self.erase(d) def is_correct_type(self, w_obj): w_type = self.space.type(w_obj) return w_type.compares_by_identity() def _never_equal_to(self, w_lookup_type): return False def w_keys(self, w_dict): return self.space.newlist(self.unerase(w_dict.dstorage).keys()) create_iterator_classes(IdentityDictStrategy)