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)
