Looks up the next available name for the inputed node name.
        
        :param      name    <str>
188961
def uniqueNodeName( self, name ):
        
        nodenames   = []
        for node in self.items():
            if ( isinstance(node, XNode) ):
                nodenames.append( node.objectName() )
        
        basename    = nativestring(name)
        index       = 1
        name        = basename
        
        while ( name in nodenames ):
            name = '%s%02i' % (basename, index)
            index += 1
        
        return name
926848
def newNodeEatName(self, name):
        
        ret = libxml2mod.xmlNewNodeEatName(self._o, name)
        if ret is None:raise treeError('xmlNewNodeEatName() failed')
        __tmp = xmlNode(_obj=ret)
        return __tmp
168312
def get_child_by_name(self, name):
        
        for c in self.child_nodes:
            if c.name == name:
                return c
        return None
1154397
private static String getNodeName(Node n) {
        String nodeName = n.getLocalName();
        if (nodeName == null || nodeName.length() == 0) {
            nodeName = n.getNodeName();
        }
        return nodeName;
    }
1298348
def _search_tree(self, name):
        """"""
        tpl1 = "{sep}{name}{sep}".format(sep=self._node_separator, name=name)
        tpl2 = "{sep}{name}".format(sep=self._node_separator, name=name)
        tpl3 = "{name}{sep}".format(sep=self._node_separator, name=name)
        return sorted(
            [
                node
                for node in self._db
                if (tpl1 in node)
                or node.endswith(tpl2)
                or node.startswith(tpl3)
                or (name == node)
            ]
        )
3313
def name(self, name: str):
        

        self.pathName = os.path.join(self.path, name)
1073172
def name(self, names=None):
        
        if names is None or not names:
            return self
        nodes = []
        for node in self.nodes:
            if any(name == node.name for name in names):
                nodes.append(node)
        self.nodes = nodes
        return self
253950
def get_name(self, name):
        """"""
        if name not in self.get_names():
            raise exceptions.NameNotFoundError('name %s not found' % name)
        return self.get_names()[name]
408855
def get(self, name: str) -> Optional[ListEntry]:
        
        parts = name.split(self._delimiter)
        try:
            node = self._find(self._root, *parts)
        except KeyError:
            return None
        else:
            marked = self._marked.get(name)
            return ListEntry(name, node.exists, marked, bool(node.children))
243975
def get_available_name(self, name):
        
        local_available_name = self.local.get_available_name(name)
        remote_available_name = self.remote.get_available_name(name)

        if remote_available_name > local_available_name:
            return remote_available_name
        return local_available_name
257340
def name(self):
        """"""
        # pylint:disable=E1101
        return next((self.names.get(x) for x in self._locales if x in
                     self.names), None)
238681
def prefix(self, name):
        
        a_node = self.adapter.get_node_attribute_node(self.impl_element, name)
        if a_node is None:
            return None
        return a_node.prefix
1216907
def lookupByName(self, name):
        
        res = yield queue.executeInThread(self.connection.lookupByName, name)
        return self.DomainClass(self, res)
41090
def node_name(self, value):
        
        if value == self._defaults['ai.internal.nodeName'] and 'ai.internal.nodeName' in self._values:
            del self._values['ai.internal.nodeName']
        else:
            self._values['ai.internal.nodeName'] = value
650473
def visit_Name(self, node):
        
        if isinstance(node.ctx, (ast.Store, ast.Param)):
            self.result.add(node.id)
519272
def remove_allocated_node_name(self, name):
        

        if name in self._allocated_node_names:
            self._allocated_node_names.remove(name)
722450
def find(self, name):
        
        for node in self.climb(whole=True):
            if node.name == name:
                return node
        return None