Returns the node object for u in V or throws an error if the node does node exist.
351990
function _safeGetNode(g, u) {
    var V = g._nodes;
    if (!(u in V)) {
      throw new Error("Node not in graph: " + u);
    }
    return V[u];
  }
174738
def _get_go2pydotnode(self):
        """"""
        go2node = {}
        go2obj = self.gosubdag.go2obj
        get_node = self.pydotnodego.get_node
        for goid in self.get_goids_plt():
            goobj = go2obj[goid]
            node = get_node(goid, goobj)
            go2node[goid] = node
            if goid != goobj.id: # goid is an alias for goobj
                go2node[goobj.id] = node
        return go2node
886682
def get_node(self, key):
    """"""
    if key in self.names:
      return self.values.get_member_node(key) if hasattr(self.values, 'get_member_node') else None
    return self.parent.get_node(key)
667198
Node getUserNode(Session session, String userName) throws PathNotFoundException, RepositoryException
   {
      return (Node)session.getItem(getUserNodePath(userName));
   }
1047411
def get_node(request):
    """"""
    api_major_int = 2 if d1_gmn.app.views.util.is_v2_api(request) else 1
    node_pretty_xml = d1_gmn.app.node.get_pretty_xml(api_major_int)
    return django.http.HttpResponse(node_pretty_xml, d1_common.const.CONTENT_TYPE_XML)
542023
def find(self, node, path):
        """"""

        return node.find(path, namespaces=self.namespaces)
688735
def node_iterator(self):
        
        return iter(self._node_attributes)

	def has_hypernode(self, hypernode):
        """Determines if a specific hypernode is present in the hypergraph.

        :param node: reference to hypernode whose presence is being checked.
        :returns: bool -- true iff the node exists in the hypergraph.

        """
        return hypernode in self._hypernode_attributes
1084520
def getobjectswithnode(idf, nodekeys, nodename):
    """"""
    keys = nodekeys
    # TODO getidfkeyswithnodes needs to be done only once. take out of here
    listofidfobjects = (idf.idfobjects[key.upper()] 
                for key in keys if idf.idfobjects[key.upper()])
    idfobjects = [idfobj 
                    for idfobjs in listofidfobjects 
                        for idfobj in idfobjs]
    objwithnodes = []
    for obj in idfobjects:
        values = obj.fieldvalues
        fdnames = obj.fieldnames
        for value, fdname in zip(values, fdnames):
            if fdname.endswith('Node_Name'):
                if value == nodename:
                    objwithnodes.append(obj)
                    break
    return objwithnodes
1254039
public <T> T lookupNodeDatum (Function<NodeObject,T> op)
    {
        for (T value :
                Iterables.filter(Iterables.transform(getNodeObjects(), op), Predicates.notNull())) {
            return value;
        }
        return null;
    }
233510
function getForInVariableSymbol(node) {
            var initializer = node.initializer;
            if (initializer.kind === 219 /* VariableDeclarationList */) {
                var variable = initializer.declarations[0];
                if (variable && !ts.isBindingPattern(variable.name)) {
                    return getSymbolOfNode(variable);
                }
            }
            else if (initializer.kind === 69 /* Identifier */) {
                return getResolvedSymbol(initializer);
            }
            return undefined;
        }
758688
def get_node(self, node_id):
        

        try:
            UUID(node_id, version=4)
        except ValueError:
            raise aiohttp.web.HTTPBadRequest(text="Node ID {} is not a valid UUID".format(node_id))

        for node in self._nodes:
            if node.id == node_id:
                return node

        raise aiohttp.web.HTTPNotFound(text="Node ID {} doesn't exist".format(node_id))
603010
def ns(self):
        
        ret = libxml2mod.xmlNodeGetNs(self._o)
        if ret is None:return None
        __tmp = xmlNs(_obj=ret)
        return __tmp
969856
def get_node(self, key):
        """"""
        pos = self._get_node_pos(key)
        if pos is None:
            return None
        return self._hashring[self._sorted_keys[pos]]
202200
function() {
    var op
      , node = this.equality();
    while (op = this.accept('is a')) {
      this.operand = true;
      if (!node) this.error('illegal unary "' + op + '", missing left-hand operand');
      node = new nodes.BinOp(op.type, node, this.equality());
      this.operand = false;
    }
    return node;
  }
1135271
def _get(self, node, key):
        
        node_type = self._get_node_type(node)

        if node_type == NODE_TYPE_BLANK:
            return BLANK_NODE

        if node_type == NODE_TYPE_BRANCH:
            # already reach the expected node
            if not key:
                return node[-1]
            sub_node = self._decode_to_node(node[key[0]])
            return self._get(sub_node, key[1:])

        # key value node
        curr_key = without_terminator(unpack_to_nibbles(node[0]))
        if node_type == NODE_TYPE_LEAF:
            return node[1] if key == curr_key else BLANK_NODE

        if node_type == NODE_TYPE_EXTENSION:
            # traverse child nodes
            if starts_with(key, curr_key):
                sub_node = self._decode_to_node(node[1])
                return self._get(sub_node, key[len(curr_key):])
            else:
                return BLANK_NODE
1181747
function(node) {
        var data = {}

        var key = null
        for (var i = 0, len = node.childNodes.length; i < len; i++) {
            var child = node.childNodes[i]
            if (child.nodeType != ELEMENT_NODE) {
                continue
            }

            // Grab the key, next noe should be the value
            if (child.tagName == 'key') {
                key = child.firstChild.nodeValue
            } else {
                // Parse the value node
                data[key] = this._parseNode(child)
            }
        }


        return data
    }
974234
def findNode(self, node):
        
        ident = self.getRawIdent(node)
        if ident is None:
            ident = node
        try:
            return self.graph.node_data(ident)
        except KeyError:
            return None