def copy(self,invalid_listener,peered,multi_threaded): ''' Returns a deep copy of the object. ''' # will be used as initial_val when constructing copied # InternalMap that we return. new_internal_val = {} val_to_copy = self.val for key in val_to_copy: to_copy = val_to_copy[key] if is_reference_container(to_copy): to_copy = to_copy.copy(invalid_listener,peered,multi_threaded) elif isinstance(to_copy,WaldoObj): if to_copy.is_value_type(): to_copy = to_copy.get_val(invalid_listener) else: to_copy = to_copy.copy( invalid_listener,peered,multi_threaded) new_internal_val[key] = to_copy if multi_threaded: return InternalMap( self.host_uuid,peered,new_internal_val) else: return SingleThreadInternalMap( self.host_uuid,peered,new_internal_val)
def assign_on_key(self,lhs,key,rhs,active_event): ''' For bracket statements + struct statements ''' if not isinstance(lhs,WaldoObj): return False raw_key = self.get_val_if_waldo(key,active_event) if wVariables.is_non_ext_text_var(lhs): raw_rhs = self.get_val_if_waldo(rhs,active_event) to_overwrite_string = lhs.get_val(active_event) to_overwrite_string[raw_key] = raw_rhs lhs.write_val(active_event,to_overwrite_string) elif isinstance(lhs,wVariables.WaldoExtTextVariable): raw_rhs = self.get_val_if_waldo(rhs,active_event) to_overwrite_string = lhs.get_val(active_event).get_val(active_event) to_overwrite_string[raw_key] = raw_rhs lhs.get_val(active_event).write_val(active_event,to_overwrite_string) elif waldoReferenceContainerBase.is_reference_container(lhs): # just write the value explicitly for now. Later, will # need to check if we need to wrap it first. lhs.write_val_on_key(active_event,raw_key,rhs) else: # just write the value explicitly for now. Later, will # need to check if we need to wrap it first. lhs.get_val(active_event).write_val_on_key(active_event,raw_key,rhs) return True
def append_val(self,invalid_listener,new_val): ''' When we append, we insert at the end of the list. Changes contains, len, keys. ''' # adding key at end. self.version_obj.add_key(len(self.val)) # if we are peered, then we want to assign into ourselves a # copy of the object, not the object itself. This will only # be a problem for container types. Non-container types # already have the semantics that they will be copied on read. # (And we throw an error if a peered variable has a container # with externals inside of it.) if self.peered: if is_reference_container(new_val): new_val = new_val.copy(invalid_listener,True,True) elif isinstance(new_val,WaldoObj): if new_val.is_value_type(): new_val = new_val.get_val(invalid_listener) else: new_val = new_val.copy(invalid_listener,True,True) self.val.append(new_val)
def append_val(self,new_val,invalid_listener,peered): # adding key at end. self.version_obj.add_key(len(self.val)) # if we are peered, then we want to assign into ourselves a # copy of the object, not the object itself. This will only # be a problem for container types. Non-container types # already have the semantics that they will be copied on read. # (And we throw an error if a peered variable has a container # with externals inside of it.) if peered: if is_reference_container(new_val): new_val = new_val.copy(invalid_listener,True,True) elif isinstance(new_val, WaldoObj): if new_val.is_value_type(): new_val = new_val.get_val(invalid_listener) else: new_val = new_val.copy(invalid_listener,True,True) if not self.written_at_least_once: self.written_at_least_once = True self.val = self.waldo_reference._non_waldo_copy() self.val.append(new_val)
def copy(self,invalid_listener,peered,multi_threaded): ''' @param {} invalid_listener @param {bool} peered --- Should the returned copy be peered or un-peered @param {bool} multi_threaded --- Do we need to use locking on the object. Ie., can the object be accessed from multiple threads simultaneously? (True if yes, False if no.) Returns a deep copy of the object. ''' # will be used as initial_val when constructing copied # InternalMap that we return. new_internal_val = [] # a peered internal map may point to values or it may point to # _ReferenceContainers. (It may not point to non # _ReferenceContainer _WaldoObjects because we disallow # externals as value types for maps and lists.) self._lock() val_to_copy = self.val self_to_copy = True if invalid_listener.uuid in self._dirty_map: self_to_copy = False val_to_copy = self._dirty_map[invalid_listener.uuid].val # if copying from internal: stay within the lock so that # nothing else can write to internal while we are. if not self_to_copy: self._unlock() for to_copy in val_to_copy: # if it's not a _ReferenceContainer, then it must just # have a value type. (See comment after # new_internal_val.) if is_reference_container(to_copy): to_copy = to_copy.copy(invalid_listener,peered,multi_threaded) elif isinstance(to_copy, WaldoObj): if to_copy.is_value_type(): to_copy = to_copy.get_val(invalid_listener) else: to_copy = to_copy.copy(invalid_listener,peered,multi_threaded) new_internal_val.append(to_copy) if self_to_copy: self._unlock() if multi_threaded: return InternalList( self.host_uuid,peered,new_internal_val) else: return SingleThreadInternalList( self.host_uuid,peered,new_internal_val)
def copy(self,invalid_listener,peered,multi_threaded): ''' @param {} invalid_listener @param {bool} peered --- Should the returned copy be peered or un-peered @param {bool} multi_threaded --- Do we need to use locking on the object. Ie., can the object be accessed from multiple threads simultaneously? (True if yes, False if no.) Returns a deep copy of the object. ''' # will be used as initial_val when constructing copied # InternalMap that we return. new_internal_val = {} self._lock() val_to_copy = self.val self_to_copy = True if invalid_listener.uuid in self._dirty_map: self_to_copy = False val_to_copy = self._dirty_map[invalid_listener.uuid].val # if copying from internal: stay within the lock so that # nothing else can write to internal while we are. if not self_to_copy: self._unlock() for key in val_to_copy: to_copy = val_to_copy[key] if is_reference_container(to_copy): to_copy = to_copy.copy(invalid_listener,peered,multi_threaded) elif isinstance(to_copy,WaldoObj): if to_copy.is_value_type(): to_copy = to_copy.get_val(invalid_listener) else: to_copy = to_copy.copy(invalid_listener,peered,multi_threaded) new_internal_val[key] = to_copy if self_to_copy: self._unlock() if multi_threaded: return InternalMap(self.host_uuid,peered,new_internal_val) else: return SingleThreadInternalMap( self.host_uuid,peered,new_internal_val)
def get_val_on_key(self,to_get_from,key,active_event): raw_key = self.get_val_if_waldo(key,active_event) if not isinstance(to_get_from,WaldoObj): return to_get_from[raw_key] # handle text + ext text if wVariables.is_non_ext_text_var(lhs): return to_get_from.get_val(active_event)[raw_key] if isinstance(lhs,wVariables.WaldoExtTextVariable): return to_get_from.get_val(active_event).get_val(active_event)[raw_key] # handle internals containers if waldoReferenceContainerBase.is_reference_container(lhs): return to_get_from.get_val_on_key(active_event,raw_key) # handle map, list, struct return to_get_from.get_val(active_event).get_val_on_key(active_event,raw_key)
def copy(self,invalid_listener,peered,multi_threaded): # will be used as initial_val when constructing copied # InternalMap that we return. new_internal_val = [] # a peered internal map may point to values or it may point to # _ReferenceContainers. (It may not point to non # _ReferenceContainer _WaldoObjects because we disallow # externals as value types for maps and lists.) val_to_copy = self.val for to_copy in val_to_copy: # if it's not a _ReferenceContainer, then it must just # have a value type. (See comment after # new_internal_val.) if is_reference_container(to_copy): to_copy = to_copy.copy( invalid_listener,peered,multi_threaded) elif isinstance(to_copy,WaldoObj): if to_copy.is_value_type(): to_copy = to_copy.get_val(invalid_listener) else: to_copy = to_copy.copy( invalid_listener,peered,multi_threaded) new_internal_val.append(to_copy) if multi_threaded: return InternalList( self.host_uuid,peered,new_internal_val) else: return SingleThreadInternalList( self.host_uuid,peered,new_internal_val)