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()