Get child elements of the injection plan tree.
TODO: use ArrayList internally (and maybe for input, too).

@return A list of injection sub-plans.
180276
@SuppressWarnings({"unchecked", "rawtypes"})
  @Override
  public Collection<InjectionPlan<?>> getChildren() {
    return (Collection) Collections.unmodifiableCollection(Arrays.asList(this.alternatives));
  }
38724
public List<MappedSuperclass<EntityMappings<T>>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<EntityMappings<T>>> list = new ArrayList<MappedSuperclass<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<EntityMappings<T>>  type = new MappedSuperclassImpl<EntityMappings<T>>(this, "mapped-superclass", childNode, node);
         list.add(type);
      }
      return list;
   }
636184
@Override
    public synchronized Enumeration getSubContexts() {
        Enumeration e = mySubContexts.elements();
        class Adapter implements Enumeration {
            Enumeration base;

            public Adapter(Enumeration e) {
                this.base = e;
            }

            @Override
            public boolean hasMoreElements() {
                return base.hasMoreElements();
            }

            @Override
            public Object nextElement() {
                return ((Entry) base.nextElement()).getCtx();
            }
        }
        return new Adapter(e);
    }
159231
public List<CmsContainerElementBean> getElements() {

        if (m_elements == null) {
            m_elements = new ArrayList<CmsContainerElementBean>();
            for (CmsContainerBean container : m_containers.values()) {
                m_elements.addAll(container.getElements());
            }
        }
        return m_elements;
    }
462768
def get_child_ids(self):
        
        id_list = []
        from ..id.objects import IdList
        for child_node in self._my_map['childNodes']:
            id_list.append(str(child_node.ident))
        return IdList(id_list)
783277
public Log[] getChildren() {
        Collection copy;

        synchronized (mChildren) {
            copy = new ArrayList(mChildren.size());
            Iterator it = mChildren.iterator();
            while (it.hasNext()) {
                Log child = (Log)((WeakReference)it.next()).get();
                if (child == null) {
                    it.remove();
                }
                else {
                    copy.add(child);
                }
            }
        }

        return (Log[])copy.toArray(new Log[copy.size()]);
    }
816568
protected Object[] getChildren() {
        if (children != null) {
            return children;
        }

        ArrayList<DebugVariable> fields = mVariable.getFieldList();
        if (fields != null) {
            children = new VariableNode[fields.size()];
            for (int i = 0; i < fields.size(); i++) {
                DebugVariable variable = fields.get(i);
                children[i] = new VariableNode(variable);
            }
            return children;
        }
        return null;
    }
400570
public List<String> getSubItems() {

        if (isGroupContainer()) {
            return m_subItems;
        } else if (isInheritContainer()) {
            List<String> result = new ArrayList<String>();
            for (CmsInheritanceInfo info : m_inheritanceInfos) {
                if (info.isVisible()) {
                    result.add(info.getClientId());
                }
            }
            return result;
        } else {
            throw new UnsupportedOperationException("Only group or inherit containers have sub-items");
        }
    }
372860
public static List<Element> getChildElements(final Element elem, final DitaClass cls, final boolean deep) {
        final NodeList children = deep ? elem.getElementsByTagName("*") : elem.getChildNodes();
        final List<Element> res = new ArrayList<>(children.getLength());
        for (int i = 0; i < children.getLength(); i++) {
            final Node child = children.item(i);
            if (cls.matches(child)) {
                res.add((Element) child);
            }
        }
        return res;
    }
151634
private List<String> getChildrenList() {
        if (childrenList != null) return childrenList;

        SharedPreferences prefs = loadSharedPreferences("children");

        String list = prefs.getString(getId(), null);

        childrenList = (list == null) ? new ArrayList<String>() : new ArrayList<>(Arrays.asList(list.split(",")));
        return childrenList;
    }
182682
@Override
	public Map<String, Object> getChildren(Boolean includeInheritedFields)
	{
		Map<String, Object> fields = new HashMap<String, Object>();
		if (includeInheritedFields)
		{
			fields.putAll(super.getChildren(includeInheritedFields));
		}
		fields.put("location", this.location);
		fields.put("type", this.type);
		return fields;
	}
738468
public static List<Element> getAllChildElements(Element parent) {
        List<Element> result;
        NodeList nodes;
        int i;
        int max;
        Node node;

        result = new ArrayList<>();
        nodes = parent.getChildNodes();
        max = nodes.getLength();
        for (i = 0; i < max; i++) {
            node = nodes.item(i);
            if (node instanceof Element) {
                result.add((Element) node);
            }
        }
        return result;
    }
1040089
public List<T> getChildren(T payload) {
    List<T> children = new ArrayList<>();
    if (!mIndex.containsKey(payload)) {
      return children;
    }
    DirectedAcyclicGraphNode<T> node = mIndex.get(payload);
    for (DirectedAcyclicGraphNode<T> child : node.getChildren()) {
      children.add(child.getPayload());
    }
    return children;
  }
1120324
public Object[] getChildren(Object element)
	{
		if (element instanceof IResource || element instanceof INode)
		{
			IWorkbenchAdapter adapter = getAdapter(element);
			if (adapter != null)
			{
				return adapter.getChildren(element);
			}
			return NO_CHILDREN;
		}
		return NO_CHILDREN;
	}
627243
public PackageInfoList getChildren() {
        if (children == null) {
            return PackageInfoList.EMPTY_LIST;
        }
        final PackageInfoList childrenSorted = new PackageInfoList(children);
        // Ensure children are sorted
        CollectionUtils.sortIfNotEmpty(childrenSorted, new Comparator<PackageInfo>() {
            @Override
            public int compare(final PackageInfo o1, final PackageInfo o2) {
                return o1.name.compareTo(o2.name);
            }
        });
        return childrenSorted;
    }
1012426
public synchronized List<INode> getRootElementList()
	{
		List<INode> list = new Vector<INode>();
		for (IVdmSourceUnit unit : vdmSourceUnits)
		{
			list.addAll(unit.getParseList());
		}
		return list;
	}
19795
public List children() {
        if (value == null) {
            return new NodeList();
        }
        if (value instanceof List) {
            return (List) value;
        }
        // we're probably just a String
        List result = new NodeList();
        result.add(value);
        return result;
    }