Return visited children

 @return [Array<Parser::Ast::Node>]

 @api private
342332
def visited_children
      children.map do |node|
        if node.is_a?(Parser::AST::Node)
          visit(node)
        else
          node
        end
      end
    end
941787
def get_tree_members(self):
        

        members = []
        queue = deque()
        queue.appendleft(self)
        visited = set()

        while len(queue):
            node = queue.popleft()

            if node not in visited:
                members.extend(node.get_member_info())
                queue.extendleft(node.get_children())
                visited.add(node)

        return [{attribute: member.get(attribute) for attribute in self.attr_list} for member in members if member]
10544
def each_element(e_node_type=nil, &block) 
		@children.each do |c| 
			if c.kind_of? MDElement
				if (not e_node_type) || (e_node_type == c.node_type)
					block.call c
				end
				c.each_element(e_node_type, &block)
			end
		end
	end
5768
function tree() {
            var result = {
                name: 'root',
                children: []
            }

            function _parseChildren(parentClientId, children) {
                Util.each(CACHE, function(item) {
                    if (item.parentClientId === parentClientId) {
                        children.push({
                            name: item.moduleId + ',' + item.clientId,
                            module: item,
                            children: _parseChildren(item.clientId, [])
                        })
                    }
                })
                return children
            }

            _parseChildren(Constant.ROOT_CLIENT_ID, result.children)

            return result
        }
288304
def traverse(sexp, visitor, context=Visitor::Context.new)
      element_name, attrs, children = decompose_sexp(sexp)
      
      non_ns_attrs, ns_bindings = Namespace::non_ns_attrs_ns_bindings(context.ns_stack, element_name, attrs)

      context.ns_stack.push(ns_bindings)

      eelement_name = Namespace::explode_qname(context.ns_stack, element_name)
      eattrs = Namespace::explode_attr_qnames(context.ns_stack, non_ns_attrs)

      begin
        visitor.element(context, eelement_name, eattrs, ns_bindings) do
          children.each_with_index do |child, i|
            if child.is_a?(Array)
              traverse(child, visitor, context)
            else
              visitor.text(context, child)
            end
          end
        end
      ensure
        context.ns_stack.pop
      end

      visitor
    end
1332223
public Collection<CallTreeNode> getChildren() {
		return children == null ? Collections.<CallTreeNode>emptyList() : children.values();
	}
577423
private void visitChildren(Node parent, Collection<Class<? extends Node>> includeNodes) {
    Node child = parent.getFirstChild();
    while (child != null) {
      // A subclass of this visitor might modify the node, resulting in getNext returning a different node or no
      // node after visiting it. So get the next node before visiting.
      Node next = child.getNext();
      if (includeNodes.contains(child.getClass())) {
        child.accept(this);
      } else {
        visitChildren(child, includeNodes);
      }
      child = next;
    }
  }
228578
def iter_children(self, key=None):
        
        """
        tag = None

        if key:
            tag = self._get_aliases().get(key)

            if not tag:
                raise KeyError(key)

        for child in self._xml.iterchildren(tag=tag):
            if len(child):
                yield self.__class__(child)
            else:
                yield Literal(child)
477201
def get_children(self):
        """"""
        next_zoom = self.zoom + 1
        return [
            self.tile_pyramid.tile(
                next_zoom,
                self.row * 2 + row_offset,
                self.col * 2 + col_offset
            )
            for row_offset, col_offset in [
                (0, 0),  # top left
                (0, 1),  # top right
                (1, 1),  # bottom right
                (1, 0),  # bottom left
            ]
            if all([
                self.row * 2 + row_offset < self.tp.matrix_height(next_zoom),
                self.col * 2 + col_offset < self.tp.matrix_width(next_zoom)
            ])
        ]
433353
def get_children(self, path, watch=None):
        """"""
        _log.debug(
            "ZK: Getting children of {path}".format(path=path),
        )
        return self.zk.get_children(path, watch)
723732
function children(node) {
    var result = [];
    for (var k in node) {
        if (!node.hasOwnProperty(k))
            continue;
        if (k[0] === '$')
            continue;
        var val = node[k];
        if (!val)
            continue;
        if (typeof val === "object" && typeof val.type === "string") {
            result.push(val);
        }
        else if (val instanceof Array) {
            for (var i=0; i<val.length; i++) {
                var elm = val[i];
                if (typeof elm === "object" && typeof elm.type === "string") {
                    result.push(elm);
                }
            }
        } 
    }
    return result;
}
1341311
protected List<R> visitChildren(ParentNode<? extends N> node) {
    List<R> results = new ArrayList<>(node.numChildren());
    for (N child : node.getChildren()) {
      results.add(visit(child));
    }
    return results;
  }
737755
def visit(ast_node, parent)
      klass = TYPES[ast_node.type] || return
      klass.new.build_from_ast(ast_node).tap do |node|
        parent.children << node
      end
    end
749742
def children(self):
        
        impl_nodelist = self.adapter.get_node_children(self.impl_node)
        return self._convert_nodelist(impl_nodelist)
821218
def _get_children(self, node):
        """"""
        children = ast.get_children(node)
        return [child for child in children
                if not isinstance(child, ast.expr_context)]
986926
public function getChildren()
    {
        $nodes = [];
        try {
            $child = $this->firstChild();
            do {
                $nodes[] = $child;
                $child   = $this->nextChild($child->id());
            } while ( ! is_null($child));
        } catch (ChildNotFoundException $e) {
            // we are done looking for children
        }

        return $nodes;
    }
1312331
def children(opt = {})
      raise ArgumentError, '#children can not take an index value' if opt[:index]

      xpath_adjacent(opt.merge(adjacent: :child, plural: true))
    end