.. deprecated:: 2.0
       Use :any:`BSP.children` instead.
558247
def bsp_right(node: tcod.bsp.BSP) -> Optional[tcod.bsp.BSP]:
    
    return None if not node.children else node.children[1]
446531
def only_child(of_type)
      lambda do |element|
        # Element must be inside parent element.
        return false unless element.parent and element.parent.tag?
        name = of_type ? element.name : nil
        other = false
        for child in element.parent.children
          # Skip text nodes/comments.
          if child.tag? and (name == nil or child.name == name)
            unless child.equal?(element)
              other = true
              break
            end
          end
        end
        !other
      end
    end
768923
def in_order(self) -> Iterator["BSP"]:
        
        if self.children:
            yield from self.children[0].in_order()
            yield self
            yield from self.children[1].in_order()
        else:
            yield self
236673
def skip_child(self, tree: ast.Node, child_name: str) -> bool:
        
        if isinstance(tree, ast.Class) and child_name == 'parent' or \
                isinstance(tree, ast.ClassModificationArgument) and child_name in ('scope', '__deepcopy__'):
            return True
        return False
357812
function renderTypesWithChildren( types, templates, locals ) {
   return types.map( type => {
      const members = ( type.children || [] )
         .map( member => {
            const renderData = ({ ...locals, ...member, fullName: `${type.name}.${member.name}` });
            return templates[ isFunction( member ) ? 'function' : 'property' ]( renderData );
         } )
         .join( '' );
      return { ...locals, ...type, members };
   } )
   .map( templates.type ).join( '' );
}
757709
def get_children_of(self, component, kind=None):
        

        structure, trace, item = self._get_structure_and_trace(component)
        item_kind, item_label = item.split(':')

        if isinstance(kind, str):
            kind = [kind]

        if item_kind not in ['orbit']:
            # return None
            return []
        else:
            items = self._get_by_trace(structure, trace[:-1]+[trace[-1]+1])
            # we want to ignore suborbits
            #return [str(ch.split(':')[-1]) for ch in items if isinstance(ch, unicode)]
            return [str(ch.split(':')[-1]) for ch in items if isinstance(ch, unicode) and (kind is None or ch.split(':')[0] in kind)]
396308
def filter_children(self, ctype: ContentType = None) -> List[SchemaNode]:
        
        if ctype is None:
            ctype = self.content_type()
        return [c for c in self.children if
                not isinstance(c, (RpcActionNode, NotificationNode)) and
                c.content_type().value & ctype.value != 0]
989029
def convert(cls, tree):
        

        if isinstance(tree, Tree):
            children = [cls.convert(child) for child in tree]
            if isinstance(tree, MetricalTree):
                return cls(tree._cat, children, tree._dep, tree._lstress)
            elif isinstance(tree, DependencyTree):
                return cls(tree._cat, children, tree._dep)
            else:
                return cls(tree._label, children)
        else:
            return tree
70685
function removeChildrenL2(data = []) {
  const ds = cloneDeep(data);
  ds.forEach((item) => {
    if (item.children) {
      item.children.forEach((subItem) => {
        if (subItem.children) {
          delete subItem.children;
        }
      });
    }
  });
  return ds;
}
253706
def replaceChild(self, new_child: AbstractNode,
                     old_child: AbstractNode) -> AbstractNode:
        """"""
        return self._replace_child(new_child, old_child)
1079065
function(children, options){
			children = (children || []).slice(0).sort(sortChildren);
			var res = "";
			children.forEach(function(child){
				res += options.fn(child)
			});
			return res;
		}
5568
def is_child_of(self, node):
        
        return node.get_children().filter(pk=self.pk).exists()
704249
def iterchildren(self):
        """"""

        child_iter = self.model.iter_children(self.iter)
        return TreeModelRowIter(self.model, child_iter)
1077088
function flattenChildren(children, selfDebugID) {
  if (children == null) {
    return children;
  }
  var result = {};

  if ("development" !== 'production') {
    traverseAllChildren(children, function (traverseContext, child, name) {
      return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
    }, result);
  } else {
    traverseAllChildren(children, flattenSingleChildIntoContext, result);
  }
  return result;
}
850515
def simplify
      if children.length == 1
        # AND or OR constructs do nothing if they only have one operand
        # So remove the logal operator from the AST by simply using the opeand
        return children.first.simplify
      else
        # nested AND or OR constructs can be combined into one construct
        @children = children.map { |c| c.simplify }.map { |c| self.compatible_with(c) ? c.children : c }.flatten
        return self
      end
    end
1215589
function flattenChildren(children, selfDebugID) {
	  if (children == null) {
	    return children;
	  }
	  var result = {};

	  if (process.env.NODE_ENV !== 'production') {
	    traverseAllChildren(children, function (traverseContext, child, name) {
	      return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
	    }, result);
	  } else {
	    traverseAllChildren(children, flattenSingleChildIntoContext, result);
	  }
	  return result;
	}
780657
def get_objects_or_children_by_type(self, *types):
        

        objects = self.get_objects_by_type(*types)
        return objects if objects else self.get_children(*types)