def pop(self): ll = self.length() if ll == 0: raise Exception("list is empty, cannot pop") i = ll - 1 chunk_i = i // 256 target: Gindex = to_gindex(chunk_i, self.__class__.tree_depth()) if i & 0xff == 0: set_last = self.get_backing().setter(target) next_backing = set_last(zero_node(0)) else: set_last = self.get_backing().setter(target) chunk = self.get_backing().getter(target) next_backing = set_last(_new_chunk_with_bit(chunk, ll & 0xff, boolean(False))) # if possible, summarize can_summarize = (target & 1) == 0 if can_summarize: # summarize to the highest node possible. # I.e. the resulting target must be a right-hand, unless it's the only content node. while (target & 1) == 0 and target != 0b10: target >>= 1 summary_fn = next_backing.summarize_into(target) next_backing = summary_fn() set_length = next_backing.rebind_right new_length = uint256(ll - 1).get_backing() next_backing = set_length(new_length) self.set_backing(next_backing)
def pop(self): ll = self.length() if ll == 0: raise Exception("list is empty, cannot pop") i = ll - 1 target: Gindex can_summarize: bool if self.__class__.is_packed(): next_backing = self.get_backing() elem_type: Type[View] = self.__class__.element_cls() if isinstance(elem_type, BasicTypeDef): elems_per_chunk = 32 // elem_type.type_byte_length() chunk_i = i // elems_per_chunk target = to_gindex(chunk_i, self.__class__.tree_depth()) if i % elems_per_chunk == 0: chunk = zero_node(0) else: chunk = next_backing.getter(target) set_last = next_backing.setter(target) chunk = cast(BasicView, elem_type.default(None)).backing_from_base( chunk, i % elems_per_chunk) next_backing = set_last(chunk) can_summarize = (target & 1) == 0 and i % elems_per_chunk == 0 else: raise Exception( "cannot pop a packed element that is not a basic type") else: target = to_gindex(i, self.__class__.tree_depth()) set_last = self.get_backing().setter(target) next_backing = set_last(zero_node(0)) can_summarize = (target & 1) == 0 # if possible, summarize if can_summarize: # summarize to the highest node possible. # I.e. the resulting target must be a right-hand, unless it's the only content node. while (target & 1) == 0 and target != 0b10: target >>= 1 summary_fn = next_backing.summarize_into(target) next_backing = summary_fn() set_length = next_backing.rebind_right new_length = uint256(ll - 1).get_backing() next_backing = set_length(new_length) self.set_backing(next_backing)
def default_node(cls) -> Node: elem_type: Type[View] = cls.element_cls() length = cls.to_chunk_length(cls.vector_length()) if cls.is_packed(): elem = zero_node(0) else: elem = elem_type.default_node() return subtree_fill_to_length(elem, cls.tree_depth(), length)
def append(self, v: boolean): ll = self.length() if ll >= self.__class__.limit(): raise Exception("list is maximum capacity, cannot append") i = ll chunk_i = i // 256 target: Gindex = to_gindex(chunk_i, self.__class__.tree_depth()) if i & 0xff == 0: set_last = self.get_backing().setter(target, expand=True) next_backing = set_last(_new_chunk_with_bit(zero_node(0), 0, v)) else: set_last = self.get_backing().setter(target) chunk = self.get_backing().getter(target) next_backing = set_last(_new_chunk_with_bit(chunk, i & 0xff, v)) set_length = next_backing.rebind_right new_length = uint256(ll + 1).get_backing() next_backing = set_length(new_length) self.set_backing(next_backing)
def append(self, v: View): ll = self.length() if ll >= self.__class__.limit(): raise Exception("list is maximum capacity, cannot append") i = ll elem_type: Type[View] = self.__class__.element_cls() if not isinstance(v, elem_type): v = elem_type.coerce_view(v) if self.__class__.is_packed(): next_backing = self.get_backing() if isinstance(elem_type, BasicTypeDef): if not isinstance(v, BasicView): raise Exception("input element is not a basic view") basic_v: BasicView = v elems_per_chunk = 32 // elem_type.type_byte_length() chunk_i = i // elems_per_chunk target: Gindex = to_gindex(chunk_i, self.__class__.tree_depth()) if i % elems_per_chunk == 0: set_last = next_backing.setter(target, expand=True) chunk = zero_node(0) else: set_last = next_backing.setter(target) chunk = next_backing.getter(target) chunk = basic_v.backing_from_base(chunk, i % elems_per_chunk) next_backing = set_last(chunk) else: raise Exception( "cannot append a packed element that is not a basic type") else: target: Gindex = to_gindex(i, self.__class__.tree_depth()) set_last = self.get_backing().setter(target, expand=True) next_backing = set_last(v.get_backing()) set_length = next_backing.rebind_right new_length = uint256(ll + 1).get_backing() next_backing = set_length(new_length) self.set_backing(next_backing)
def default_node(cls) -> Node: return zero_node(0)
def default_node(cls) -> Node: return PairNode(zero_node(cls.contents_depth()), zero_node(0)) # mix-in 0 as list length
def default_node(cls) -> Node: return subtree_fill_to_length(zero_node(0), cls.tree_depth(), ((cls.vector_length() + 255) // 256))