def _g_refNode(self, childNode, childName, validate=True): """ Insert references to a `childNode` via a `childName`. Checks that the `childName` is valid and does not exist, then creates references to the given `childNode` by that `childName`. The validation of the name can be omitted by setting `validate` to a false value (this may be useful for adding already existing nodes to the tree). """ # Check for name validity. if validate: checkNameValidity(childName) childNode._g_checkName(childName) # Check if there is already a child with the same name. # This can be triggered because of the user # (via node construction or renaming/movement). # Links are not checked here because they are copied and referenced # using ``File.getNode`` so they already exist in `self`. if (not isinstance(childNode, Link)) and childName in self: raise NodeError( "group ``%s`` already has a child node named ``%s``" % (self._v_pathname, childName)) # Show a warning if there is an object attribute with that name. if childName in self.__dict__: warnings.warn( "group ``%s`` already has an attribute named ``%s``; " "you will not be able to use natural naming " "to access the child node" % (self._v_pathname, childName), NaturalNameWarning) # Check group width limits. if len(self._v_children) + len(self._v_hidden) >= self._v_maxGroupWidth: self._g_widthWarning() # Update members information. # Insert references to the new child. # (Assigned values are entirely irrelevant.) if isVisibleName(childName): # Visible node. self.__members__.insert(0, childName) # enable completion self._v_children[childName] = None # insert node if isinstance(childNode, Unknown): self._v_unknown[childName] = None elif isinstance(childNode, Link): self._v_links[childName] = None elif isinstance(childNode, Leaf): self._v_leaves[childName] = None elif isinstance(childNode, Group): self._v_groups[childName] = None else: # Hidden node. self._v_hidden[childName] = None # insert node
def _g_addChildrenNames(self): """ Add children names to this group taking into account their visibility and kind. """ myDict = self.__dict__ # The names of the lazy attributes myDict['__members__'] = members = [] """The names of visible children nodes for readline-style completion.""" myDict['_v_children'] = children = _ChildrenDict(self) """The number of children hanging from this group.""" myDict['_v_groups'] = groups = _ChildrenDict(self) """Dictionary with all groups hanging from this group.""" myDict['_v_leaves'] = leaves = _ChildrenDict(self) """Dictionary with all leaves hanging from this group.""" myDict['_v_links'] = links = _ChildrenDict(self) """Dictionary with all links hanging from this group.""" myDict['_v_unknown'] = unknown = _ChildrenDict(self) """Dictionary with all unknown nodes hanging from this group.""" myDict['_v_hidden'] = hidden = _ChildrenDict(self) """Dictionary with all hidden nodes hanging from this group.""" # Get the names of *all* child groups and leaves. (groupNames, leafNames, linkNames, unknownNames) = \ self._g_listGroup(self._v_parent) # Separate groups into visible groups and hidden nodes, # and leaves into visible leaves and hidden nodes. for (childNames, childDict) in ( (groupNames, groups), (leafNames, leaves), (linkNames, links), (unknownNames, unknown)): for childName in childNames: # See whether the name implies that the node is hidden. # (Assigned values are entirely irrelevant.) if isVisibleName(childName): # Visible node. members.insert(0, childName) children[childName] = None childDict[childName] = None else: # Hidden node. hidden[childName] = None