Yield all direct children of this object.
358312
def _children(self):
        """"""
        for codeobj in self.parameters:
            yield codeobj
        for codeobj in self.body._children():
            yield codeobj
128644
def each
      child_after = 0
      while (child_after = FindWindowEx(@parent.handle, child_after, nil, nil)) > 0 do
        window = Window.new child_after
        # immediate children only
        yield window if (window.parent) && (window.parent.handle == @parent.handle)
      end
    end
654280
def walk_tree(root):
    """"""
    yield root

    for child in root.children:
        for el in walk_tree(child):
            yield el
758790
def all_child_sprites(self):
        """"""
        for sprite in self.sprites:
            for child_sprite in sprite.all_child_sprites():
                yield child_sprite
            yield sprite
474769
def get_children(self):
        """"""
        if self.is_leaf():
            return get_result_class(self.__class__).objects.none()
        return get_result_class(self.__class__).objects.filter(
            depth=self.depth + 1,
            path__range=self._get_children_path_interval(self.path)
        ).order_by(
            'path'
        )
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)
601721
def _yield_all(self, l):
        '''
        
        '''
        if l is not None:
            if type(l) in [list, tuple]:
                for f in l:
                    for x in self._yield(f): yield x
            else:
                for x in self._yield(l): yield x
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
794412
def children(self, recursive=False):
        
        for i in xrange(self.childCount()):
            child = self.child(i)
            yield child
            
            if recursive:
                for subchild in child.children(recursive=True):
                    yield subchild
148053
def get_children(self):
        """"""
        if hasattr(self, '_cached_children'):
            children = self._toplevel().objects.filter(
                pk__in=[n.pk for n in self._cached_children]
            )
            children._result_cache = self._cached_children
            return children
        else:
            return self.get_descendants(include_self=False, depth=1)
580436
def descendents(self):
        """"""

        for c in self.children:
            yield c

            for d in c.descendents:
                yield d
911118
def conditions(self):
        """"""
        for idx in six.moves.range(1, len(self.children), 2):
            yield (self.children[idx - 1], self.children[idx])
726864
def all_original_children(self):
        ''''''
        return chain.from_iterable(
            c.all_nodes_in_subtree()
            for lnk, c in self.children
            if lnk == self.LINK_CHILD)
150615
def children(self):
        """"""
        from warnings import warn
        warn("Deprecated. Use Scraper.descendants.", DeprecationWarning)
        for descendant in self.descendants:
            yield descendant
91713
def get_all_category_children
      direct_children = self.category_children
      all_children = []

      direct_children.each do |direct_child|
        all_children.push(direct_child)
        all_children = all_children + direct_child.get_all_category_children
      end

      all_children
    end
688970
def each_node(&block)
      return to_enum :each_node unless block_given?
      children_nodes.each do |child|
        child.each_node(&block)
      end
      yield self
      self
    end
531559
def get_children(self):
        
        for expr, var in self.items:
            yield expr
            if var:
                yield var
        yield from self.body