Get end node

        :return: StructuredNode
517444
def end_node(self):
        
        return db.cypher_query("MATCH (aNode) "
                               "WHERE id(aNode)={nodeid} "
                               "RETURN aNode".format(nodeid=self._end_node_id),
                               resolve_objects = True)[0][0][0]
115062
def _get_start_end(parts, index=7):
    
    start = parts[1]
    end = [x.split("=")[-1] for x in parts[index].split(";") if x.startswith("END=")]
    if end:
        end = end[0]
        return start, end
    return None, None
103368
def get_node(self):
        """"""
        # already added title, text frames
        # add animation chunks
        if self.animations:
            anim_par = el("anim:par", attrib={"presentation:node-type": "timing-root"})
            self._page.append(anim_par)
            anim_seq = sub_el(
                anim_par, "anim:seq", attrib={"presentation:node-type": "main-sequence"}
            )
            for a in self.animations:
                a_node = a.get_node()
                anim_seq.append(a_node)

        # add notes now (so they are last)
        if self.notes_frame:
            notes = self.notes_frame.get_node()
            self._page.append(notes)
        if self.footer:
            self._page.attrib[ns("presentation", "use-footer-name")] = self.footer.name
        return self._page
3578
def _endStationsNode(self, name, content):
        """"""

        if name == 'callSign':
            self._callSign = content
        elif name == 'name':
            self._stationName = content
        elif name == 'affiliate':
            self._affiliate = content
        elif name == 'fccChannelNumber':
            self._fccChannelNumber = content
        elif name == 'station':
            if not self._error:
                self._importer.new_station(self._stationId, self._callSign,
                                          self._stationName, self._affiliate,
                                          self._fccChannelNumber)
695764
def paragraph_ends(self):
        """"""
        if not self.is_tagged(PARAGRAPHS):
            self.tokenize_paragraphs()
        return self.ends(PARAGRAPHS)
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]]
568010
def p_end_function(p):
    
    p[0] = p[1]
    p[0].append(node.return_stmt(ret=ret_expr))
    p[0].append(node.comment_stmt("\nif __name__ == '__main__':\n    pass"))
973641
def get_sub_node(self, node):
        """"""

        subnode = node.find('office:document')
        if subnode:
            mimetype = subnode.attrs['office:mimetype']
            self.type = MIMEMAP[mimetype]
            node = node.find('office:body')
        return node
1359880
private List<Long> getPathToNode(Node endNode) {
        List<Long> path = new ArrayList<>();
        // Reverse the path.
        Node curNode = endNode;
        do {
            path.add(0, curNode.id);
            curNode = m_nodePool.getNodeAtIdx(curNode.pidx);
        } while (curNode != null);

        return path;
    }
64107
def endElement(self, name):
        
        if name in self.ignore_end:
            return
        try:
            handler = getattr(self, '_handle_end_%s' % name)
        except AttributeError:
            raise KeyError("Unknown element end '%s'" % name)
        handler()
320608
def end_line(node)
      child = node
      prev_child = node
      until [nil, prev_child].include?(child = last_child(child))
        prev_child = child
      end

      # Fall back to prev_child if last_child() returned nil (i.e. node had no
      # children with line numbers)
      (child || prev_child).line
    end
112569
def get_node(self, name, memory=False, binary=False):
        
        return self._api_get(
            url='/api/nodes/{0}'.format(name),
            params=dict(
                binary=binary,
                memory=memory,
            ),
        )
137734
def _parse_description(self, node):
        # type: (ElementTree.Element) -> EndpointDescription
        
        endpoint = {}
        for prop_node in node.findall(TAG_PROPERTY):
            name, value = self._parse_property(prop_node)
            endpoint[name] = value

        return EndpointDescription(None, endpoint)
572176
def getTypeLastNode(self, type_):
        

        lastNode = ""
        if type_ and (type(type_) is not list) and (type(type_) is not dict):
            aType = type_.split('>')
            lastNode = aType[len(aType) - 1]
        return lastNode
700205
def get_node(self, node_name):
        """"""
        for node in self.nodes:
            if node.__name__ == node_name:
                return node
838219
def get_node(self, node_id):
        """"""
        try:
            node_object = self.nodes[node_id]
        except KeyError:
            raise NonexistentNodeError(node_id)
        return node_object
1088420
def get_tail(self):
        
        node = self.head
        last_node = self.head

        while node is not None:
            last_node = node
            node = node.next_node

        return last_node