Get start node

        :return: StructuredNode
497580
def start_node(self):
        
        return db.cypher_query("MATCH (aNode) "
                               "WHERE id(aNode)={nodeid} "
                               "RETURN aNode".format(nodeid=self._start_node_id),
                               resolve_objects = True)[0][0][0]
1089418
function (start, end) {
            var ret = null, l;
            l = end - start;
            if (l > 0) {
                ret = this.nodeFactory.createCDataNode(this.page, start, end);
            }
            return ret;
        }
1037820
def nodes(self):
        
        if not hasattr(self, '_nodes'):
            base_url = "{}/{}".format(NodeBalancerConfig.api_endpoint, NodeBalancerNode.derived_url_path)
            result = self._client._get_objects(base_url, NodeBalancerNode, model=self, parent_id=(self.id, self.nodebalancer_id))

            self._set('_nodes', result)

        return self._nodes
1253683
def initial(self, request, *args, **kwargs):
        
        super(NodeLinkList, self).initial(request, *args, **kwargs)
        # ensure node exists
        try:
            self.node = Node.objects.published()\
                                    .accessible_to(request.user)\
                                    .get(slug=self.kwargs.get('slug', None))
        except Node.DoesNotExist:
            raise Http404(_('Node not found.'))
        # check permissions on node (for link creation)
        self.check_object_permissions(request, self.node)
        # return only links of current node
        self.queryset = Link.objects.select_related('node_a', 'node_b')\
                                    .accessible_to(self.request.user)\
                                    .filter(Q(node_a_id=self.node.id) |
                                            Q(node_b_id=self.node.id))
556310
function getDomNode(node, start, ltr, startFromChild, fn, guard) {
    var tmpNode = startFromChild && node[start],
        parent;
    !tmpNode && (tmpNode = node[ltr]);
    while (!tmpNode && (parent = (parent || node).parentNode)) {
        if (parent.tagName == 'BODY' || guard && !guard(parent)) {
            return null;
        }
        tmpNode = parent[ltr];
    }
    if (tmpNode && fn && !fn(tmpNode)) {
        return  getDomNode(tmpNode, start, ltr, false, fn);
    }
    return tmpNode;
}
1015924
def parse_on_start(self, node):
        

        event_handler = OnStart()

        self.current_regime.add_event_handler(event_handler)

        self.current_event_handler = event_handler
        self.process_nested_tags(node)
        self.current_event_handler = None
783048
def getRootNode(nodes):
    ''''''
    max = 0
    root = None
    for i in nodes:
        if len(i.children) > max:
            max = len(i.children)
            root = i
    return root
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
746762
def getnodes(self, name):
        "'"
        for node in self.nodes:
            if striptag(node.tag) == name:
                yield node
1165094
def getNextNode(nodes,usednodes,parent):
    ''''''
    for e in edges:
        if e.source==parent:
            if e.target in usednodes:
                x = e.target
                break
        elif e.target==parent:
            if e.source in usednoes:
                x = e.source
                break  
    return x
103127
def start(self, nodes=None):
        
        if not self.is_connected():
            return None

        nodes = nodes or self.nodes
        result = []

        for node in nodes:
            if node.state == 'running':
                logging.warning('Node %s is already "running".', node.name)
                continue
            try:
                status = self.gce.ex_start_node(node)
                if status:
                    result.append(node)
            except InvalidRequestError as err:
                raise ComputeEngineManagerException(err)

        return result
1112759
public Node getNode() {
        if (node == null) {
            if (resource != null) {
                node = resource.adaptTo(Node.class);
            }
        }
        return node;
    }
360559
def populate_startup_nodes(self):
        
        for item in self.startup_nodes:
            self.set_node_name(item)

        for n in self.nodes.values():
            if n not in self.startup_nodes:
                self.startup_nodes.append(n)

        # freeze it so we can set() it
        uniq = {frozenset(node.items()) for node in self.startup_nodes}
        # then thaw it back out into a list of dicts
        self.startup_nodes = [dict(node) for node in uniq]
1086394
def _is_start(event, node, tagName):  # pylint: disable=invalid-name
    """"""

    return event == pulldom.START_ELEMENT and node.tagName == tagName
140319
def atlas_node_start(atlas_state):
    
    for component in atlas_state.keys():
        log.debug("Starting Atlas component '%s'" % component)
        atlas_state[component].start()
450337
def bsp_find_node(
    node: tcod.bsp.BSP, cx: int, cy: int
) -> Optional[tcod.bsp.BSP]:
    
    return node.find_node(cx, cy)
1081035
def getNodeBeingMade(self, buid):
        '''
        
        '''
        nodeevnt = self.allbldgbuids.get(buid)
        if nodeevnt is None:
            return None
        if buid not in self.mybldgbuids:
            self.otherbldgbuids.add(buid)
        return nodeevnt[0]