Get all children including children of children

        :returns: all children including children of children
        :rtype: list of :class:`Reftrack`
        :raises: None
491269
def get_all_children(self):
        
        children = self._children[:]
        oldlen = 0
        newlen = len(children)
        while oldlen != newlen:
            start = oldlen
            oldlen = len(children)
            for i in range(start, len(children)):
                children.extend(children[i]._children)
            newlen = len(children)
        return children
640730
def get_child_models(self):
        
        child_models = []
        for plugin in self.child_model_plugin_class.get_plugins():
            child_models.append((plugin.model, plugin.model_admin))
        if not child_models:
            child_models.append((
                self.child_model_admin.base_model,
                self.child_model_admin,
            ))
        return child_models
942865
def _fetchAllChildren(self):
        
        childItems = []
        if self._array.ndim == 2:
            _nRows, nCols = self._array.shape if self._array is not None else (0, 0)
            for col in range(nCols):
                colItem = SliceRti(self._array[:, col], nodeName="channel-{}".format(col),
                                   fileName=self.fileName, iconColor=self.iconColor,
                                   attributes=self.attributes)
                childItems.append(colItem)
        return childItems
592906
def get_children(self, path, watch=None):
        
        return self._zk.get_children(self.__path(path), watch=watch)
173177
def children(self):
        
        if self._children is None:
            topdowns = tuple(Relationship.topdown())
            self._children = TermList()
            self._children.extend(
                [ other
                    for rship,others in six.iteritems(self.relations)
                        for other in others
                            if rship in topdowns
                ]
            )
        return self._children
313794
def get_children(self):
        """"""

        # FIXME: Expose iteration from CIndex, PR6125.
        def visitor(child, parent, children):
            # FIXME: Document this assertion in API.
            # FIXME: There should just be an isNull method.
            assert child != conf.lib.clang_getNullCursor()

            # Create reference to TU so it isn't GC'd before Cursor.
            child._tu = self._tu
            children.append(child)
            return 1 # continue
        children = []
        conf.lib.clang_visitChildren(self, callbacks['cursor_visit'](visitor),
            children)
        return iter(children)
1179395
def get_all_children(self):
        """"""
        all_children = set()
        for parent in self.children:
            all_children.add(parent.item_id)
            all_children |= parent.get_all_children()
        return all_children
290154
def iter_all_children(self):
        '''
        '''
        
        if self.inline_child:
            yield self.inline_child
        for x in self.children:
            yield x
943659
def count(self):
        
        total = len(self.children)
        for child in self.children:
            total += child.count()
        return total
155499
def get_child(self, *types):
        
        children = list(self.get_children(*types))
        return children[0] if any(children) else None
1047156
def getchildren(self):
        '''
        
        '''
        try:
            if self.hidden:
                return [os.path.join(self.name, child)
                        for child in sorted(self.listdir(self.name))]
            else:
                return [os.path.join(self.name, child)
                        for child in sorted(os.listdir(self.name))]
        except OSError:
            return None
345509
def recursive_children(self):
        

        for child in self.children:
            yield child

            for recursive_child in child.recursive_children:
                yield recursive_child
892760
def _descendants(self):
        
        children = self._children
        if children is not None:
            for child in children.values():
                yield from child._descendants
                yield child
577082
def published_children(self):
        """"""
        key = self.PUB_CHILDREN_KEY % self.pk
        #children = cache.get(key, None)
        # if children is None:
        children = Page.objects.filter_published(self.get_children()).all()
        #cache.set(key, children)
        return children
453666
def children(self):
        

        if isinstance(self.content, list):
            return self.content
        elif isinstance(self.content, Element):
            return [self.content]
        else:
            return []
173689
def _fetchAllChildren(self):
        
        assert self.canFetchChildren(), "canFetchChildren must be True"

        childItems = []

        # Add fields in case of an array of structured type.
        if self._isStructured:
            for fieldName in self._array.dtype.names:
                childItem = FieldRti(self._array, nodeName=fieldName, fileName=self.fileName)
                childItem._iconColor = self.iconColor
                childItems.append(childItem)

        return childItems
1266994
def getAllNodes(self):
        '''
            
        '''
        ret = TagCollection()

        for tag in self:
            ret.append(tag)
            ret += tag.getAllChildNodes()

        return ret