def test_map_descriptors():
empty = make_map_type("__getitem__", W_ImpPropertyDescriptor).EMPTY
a = W_ImpPropertyDescriptor("a")
b = W_ImpPropertyDescriptor("b")
c = W_ImpPropertyDescriptor("c")
d = W_ImpPropertyDescriptor("d")
map = empty
maps = []
for i in [a, b, c]:
map = map.add_attribute(i)
maps.append(map)
assert map.get_index(a) == 0
assert map.get_index(b) == 1
assert map.get_index(c) == 2
assert map.get_index(d) == -1
assert map.storage_size() == 3
assert empty.other_maps.get(a) is not None
assert empty.other_maps.get(a).other_maps.get(b) is not None
assert empty.other_maps.get(a).other_maps.get(b).other_maps.get(c) is not None
map_ = empty.add_attribute(b).add_attribute(a).add_attribute(c)
assert map_ is not map
assert map_.get_index(b) == 0
assert map_.get_index(a) == 1
assert map_.get_index(c) == 2
assert map_.get_index(d) == -1
def test_map():
import gc
empty = make_map_type("__getitem__", int).EMPTY
map = empty
for i in range(1, 4):
gc.collect()
map = map.add_attribute(i)
assert map.get_index(1) == 0
assert map.get_index(2) == 1
assert map.get_index(3) == 2
assert map.get_index(4) == -1
assert map.storage_size() == 3
# Check to ensure we get the same hidden class
# by adding the same attributes.
# GC aggressively to ensure we are not messing
# up due to use of weak hash tables
map2 = empty
for i in range(1, 4):
gc.collect()
map2 = map2.add_attribute(i)
assert map is map2
assert empty.other_maps.get(1) is not None
assert empty.other_maps.get(1).other_maps.get(2) is not None
assert empty.other_maps.get(1).other_maps.get(2).other_maps.get(
3) is not None
map_ = empty.add_attribute(2).add_attribute(1).add_attribute(3)
assert map_ is not map
assert map_.get_index(2) == 0
assert map_.get_index(1) == 1
assert map_.get_index(3) == 2
def test_map():
import gc
empty = make_map_type("__getitem__", int).EMPTY
map = empty
for i in range(1, 4):
gc.collect()
map = map.add_attribute(i)
assert map.get_index(1) == 0
assert map.get_index(2) == 1
assert map.get_index(3) == 2
assert map.get_index(4) == -1
assert map.storage_size() == 3
# Check to ensure we get the same hidden class
# by adding the same attributes.
# GC aggressively to ensure we are not messing
# up due to use of weak hash tables
map2 = empty
for i in range(1, 4):
gc.collect()
map2 = map2.add_attribute(i)
assert map is map2
assert empty.other_maps.get(1) is not None
assert empty.other_maps.get(1).other_maps.get(2) is not None
assert empty.other_maps.get(1).other_maps.get(2).other_maps.get(3) is not None
map_ = empty.add_attribute(2).add_attribute(1).add_attribute(3)
assert map_ is not map
assert map_.get_index(2) == 0
assert map_.get_index(1) == 1
assert map_.get_index(3) == 2
def test_map_descriptors():
import gc
empty = make_map_type("__getitem__", W_ImpPropertyDescriptor).EMPTY
a = W_ImpPropertyDescriptor("a")
b = W_ImpPropertyDescriptor("b")
c = W_ImpPropertyDescriptor("c")
d = W_ImpPropertyDescriptor("d")
map = empty
for i in [a, b, c]:
gc.collect()
map = map.add_attribute(i)
assert map.get_index(a) == 0
assert map.get_index(b) == 1
assert map.get_index(c) == 2
assert map.get_index(d) == -1
assert map.storage_size() == 3
map2 = empty
for i in [a, b, c]:
gc.collect()
map2 = map2.add_attribute(i)
assert map is map2
assert empty.other_maps.get(a) is not None
assert empty.other_maps.get(a).other_maps.get(b) is not None
assert empty.other_maps.get(a).other_maps.get(b).other_maps.get(c) is not None
map_ = empty.add_attribute(b).add_attribute(a).add_attribute(c)
assert map_ is not map
assert map_.get_index(b) == 0
assert map_.get_index(a) == 1
assert map_.get_index(c) == 2
assert map_.get_index(d) == -1
class ProxyMixin(object):
EMPTY_MAP = make_map_type("get_property_index",
W_ImpPropertyDescriptor).EMPTY
_immutable_fields_ = [
'property_map', 'property_storage[*]', 'inner', 'base'
]
@jit.unroll_safe
def init_proxy(self, inner, prop_keys, prop_vals):
assert not prop_keys and not prop_vals or len(prop_keys) == len(
prop_vals)
self.inner = inner
self.base = inner.get_base()
self.property_map = make_property_map(prop_keys, ProxyMixin.EMPTY_MAP)
self.property_storage = prop_vals[:] if prop_vals is not None else None # Ensure not resized
if not we_are_translated():
if self.property_map is not ProxyMixin.EMPTY_MAP:
assert self.property_map.storage_size() == len(prop_vals)
def get_property_index(self, index):
return self.property_storage[index]
def iterprops(self):
return self.property_map.iteritems()
def property_count(self):
return self.property_map.storage_size()
def get_proxied(self):
return self.inner
def get_base(self):
return self.base
def is_proxy(self):
return True
def get_property(self, prop, default=None):
return self.property_map.lookup(prop, self, default)
def immutable(self):
return self.base.immutable()
def tostring(self):
return self.base.tostring()
def test_map():
empty = make_map_type("__getitem__", int).EMPTY
maps = []
map = empty
for i in range(1, 4):
map = map.add_attribute(i)
maps.append(map)
assert map.get_index(1) == 0
assert map.get_index(2) == 1
assert map.get_index(3) == 2
assert map.get_index(4) == -1
assert map.storage_size() == 3
assert empty.other_maps.get(1) is not None
assert empty.other_maps.get(1).other_maps.get(2) is not None
assert empty.other_maps.get(1).other_maps.get(2).other_maps.get(3) is not None
map_ = empty.add_attribute(2).add_attribute(1).add_attribute(3)
assert map_ is not map
assert map_.get_index(2) == 0
assert map_.get_index(1) == 1
assert map_.get_index(3) == 2
def test_map_descriptors():
import gc
empty = make_map_type("__getitem__", W_ImpPropertyDescriptor).EMPTY
a = W_ImpPropertyDescriptor("a")
b = W_ImpPropertyDescriptor("b")
c = W_ImpPropertyDescriptor("c")
d = W_ImpPropertyDescriptor("d")
map = empty
for i in [a, b, c]:
gc.collect()
map = map.add_attribute(i)
assert map.get_index(a) == 0
assert map.get_index(b) == 1
assert map.get_index(c) == 2
assert map.get_index(d) == -1
assert map.storage_size() == 3
map2 = empty
for i in [a, b, c]:
gc.collect()
map2 = map2.add_attribute(i)
assert map is map2
assert empty.other_maps.get(a) is not None
assert empty.other_maps.get(a).other_maps.get(b) is not None
assert empty.other_maps.get(a).other_maps.get(b).other_maps.get(
c) is not None
map_ = empty.add_attribute(b).add_attribute(a).add_attribute(c)
assert map_ is not map
assert map_.get_index(b) == 0
assert map_.get_index(a) == 1
assert map_.get_index(c) == 2
assert map_.get_index(d) == -1
class W_InterposeStructBase(values_struct.W_RootStruct):
EMPTY_HANDLER_MAP = make_caching_map_type("get_storage_index", int).EMPTY
# The keytype for this hidden class must be a superclass of
# W_StructPropertyAccessor and W_ImpPropertyDescriptor
EMPTY_PROPERTY_MAP = make_map_type("get_storage_index", W_Object).EMPTY
_attrs_ = ['inner', 'base', 'map']
_immutable_fields_ = ['inner', 'base', 'map']
def __init__(self, inner, map):
self.inner = inner
self.map = map
if isinstance(inner, W_InterposeStructBase) and map is inner.map:
self.base = inner.base
else:
self.base = inner
def get_storage_index(self, idx):
return self._get_list(idx)
def get_proxied(self):
return self.inner
def get_base(self):
return self.base
def is_proxy(self):
return True
def get_property(self, prop, default=None):
return self.map.lookup_property(prop, self, default=default)
def immutable(self):
return get_base_object(self.base).immutable()
def tostring(self):
return get_base_object(self.base).tostring()
def post_ref_cont(self, interp, app, env, cont):
raise NotImplementedError("abstract method")
def post_set_cont(self, op, field, val, app, env, cont):
raise NotImplementedError("abstract method")
def is_non_interposing_chaperone(self):
map = jit.promote(self.map)
return (not has_accessor(map.handlers)
and has_property_descriptor(map.properties))
def replace_proxied(self, other):
storage = self._get_full_list()
return self.make(storage, other, self.map)
def struct_type(self):
return get_base_object(self.base).struct_type()
def get_handler_accessor(self, field):
idx = tag_handler_accessor(field)
return self.map.lookup_handler(idx, self)
def get_override_accessor(self, field):
idx = tag_override_accessor(field)
return self.map.lookup_handler(idx, self)
def get_handler_mutator(self, field):
idx = tag_handler_mutator(field)
return self.map.lookup_handler(idx, self)
def get_override_mutator(self, field):
idx = tag_override_mutator(field)
return self.map.lookup_handler(idx, self)
@guarded_loop(enter_above_depth(5), always_use_labels=False)
def ref_with_extra_info(self, field, app, env, cont):
handler = self.get_handler_accessor(field)
override = self.get_override_accessor(field)
if handler is None and override is None:
return self.base.ref_with_extra_info(field, app, env, cont)
if handler is not None:
cont = self.post_ref_cont(handler, app, env, cont)
if override is not None:
return override.call_with_extra_info([self.inner], env, cont, app)
return self.inner.ref_with_extra_info(field, app, env, cont)
@guarded_loop(enter_above_depth(5), always_use_labels=False)
def set_with_extra_info(self, field, val, app, env, cont):
handler = self.get_handler_mutator(field)
override = self.get_override_mutator(field)
if handler is None and override is None:
return self.base.set_with_extra_info(field, val, app, env, cont)
if handler is None:
return self.inner.set_with_extra_info(field, val, app, env, cont)
after = self.post_set_cont(override, field, val, app, env, cont)
return handler.call_with_extra_info([self, val], env, after, app)
def get_prop(self, property, env, cont):
pair = self.get_property(property, default=NONE_PAIR)
# Struct properties can only be associated with Pairs which contain both
# the override and handler for the property
assert type(pair) is Pair
op, interp = pair
if op is None or interp is None:
return self.inner.get_prop(property, env, cont)
after = self.post_ref_cont(interp, None, env, cont)
return op.call([self.inner], env, after)
@guarded_loop(enter_above_depth(5), always_use_labels=False)
def get_struct_info(self, env, cont):
handler = self.map.lookup_handler(INFO_HANDLER_IDX, self)
if handler is not None:
cont = call_cont(handler, env, cont)
return self.inner.get_struct_info(env, cont)
def get_arity(self, promote=False):
return get_base_object(self.base).get_arity(promote)
# FIXME: This is incorrect
def vals(self):
base = get_base_object(self.base)
assert isinstance(base, values_struct.W_RootStruct)
return base.vals()
