Stores the children in a list following the grid's structure

        :param children: list of fields

        :param grid: a list of list corresponding of the layout to apply to the
        given children
321155
def _childgroup(self, children, grid):
        
        result = []
        index = 0
        hidden_fields = []

        for row in grid:
            child_row = []
            width_sum = 0
            for width, filled in row:
                width_sum += width
                if width_sum > self.num_cols:
                    warnings.warn(u"It seems your grid configuration overlaps \
the bootstrap layout columns number. One of your lines is larger than {0}. \
You can increase this column number by compiling bootstrap css with \
lessc.".format(self.num_cols))

                if isinstance(filled, StaticWidget):
                    child = filled
                    child.width = width

                elif filled:
                    try:
                        child = children[index]
                    except IndexError:
                        warnings.warn(u"The grid items number doesn't \
match the number of children of our mapping widget")
                        break
                    if type(child.widget) == deform.widget.HiddenWidget:
                        hidden_fields.append(child)
                        index += 1
                        try:
                            child = children[index]
                        except IndexError:
                            warnings.warn(u"The grid items number doesn't \
match the number of children of our mapping widget")
                            break
                    child.width = width
                    index += 1
                else:
                    child = VoidWidget(width)
                child_row.append(child)
            if child_row != []:
                result.append(child_row)

        if index <= len(children):
            result.append(children[index:])

        if hidden_fields != []:
            result.append(hidden_fields)
        return result
209086
def stack(me, children)
      children = children.map{|c| c.is_a?(::Layers::LayerBase) ? c.to_node([]) : c}
      me.to_node(children)
    end
346200
def _setChildren(self):
		
		if self.index + 1 < len(self.gametree):
			self.children = [self.gametree[self.index+1]]
		else:
			self.children = map(lambda list: list[0], self.gametree.variations)
1285080
def set_many(self, nodes):
        
        data = self._prepare_nodes(nodes)
        self._set_many(data)
10762
def render_children
      children = ''

      list_item.children.each do |child|
        children += self.class.render(child, opts)
      end

      children
    end
1279279
def dfs(self):
        
        for node in self.children:
            for v in node.dfs:
                yield v
        yield self
571450
def children(self):
        
        return pvector(
            sorted(self._children.values(), key=lambda m: m.task_level))
744741
def get_children_metadata(self):
        
        metadata = dict(self._mdata['children'])
        metadata.update({'existing_children_values': self._my_map['childIds']})
        return Metadata(**metadata)
1217673
def add_children(self, *children, **kwargs):
        """"""
        for child in children:
            self.add_child(child, **kwargs)
942738
@Override
  public void setChildren(Tree[] children) {
    if (children == null) {
      System.err.println("Warning -- you tried to set the children of a SimpleTree to null.\nYou should be really using a zero-length array instead.");
      daughterTrees = EMPTY_TREE_ARRAY;
    } else {
      daughterTrees = children;
    }
  }
1058318
def children(*names)
      define_remaining_children(names)

      names.each_with_index do |name, index|
        define_child(name, index)
      end
    end
1187966
def add_children(self, frames, after=None):
        '''
        
        '''
        if after is not None:
            # if there's an 'after' parameter, add the frames in reverse so the order is
            # preserved.
            for frame in reversed(frames):
                self.add_child(frame, after=after)
        else:
            for frame in frames:
                self.add_child(frame)
207378
public void addChildren( Iterable<PlanNode> otherChildren ) {
        assert otherChildren != null;
        for (PlanNode planNode : otherChildren) {
            this.addLastChild(planNode);
        }
    }
666175
def add_children(*nodes)
      new_children = nodes.flatten
      new_children.each do |node|
        node.set_parent self
        node.add_observer(self)
      end
      changed
      notify_observers :new_children, new_children
    end
520594
def children_with_values(self):
        
        childs = []
        for attribute in self._get_all_c_children_with_order():
            member = getattr(self, attribute)
            if member is None or member == []:
                pass
            elif isinstance(member, list):
                for instance in member:
                    childs.append(instance)
            else:
                childs.append(member)
        return childs
582267
function _cacheChildren(node) {
  var children = node.get('children');
  if(children) {
    node.set('allChildren', children);
    children.forEach(_cacheChildren);
  }
}
408012
def new_children(self, **kwargs):
        """"""
        for k, v in kwargs.items():
            self.new_child(k, v)

        return self