Extract a list of runtime chain data objects (including exclusively
child channel data lists) that are using the input parent channel.

@param parent
The parent channel data object
@return an arraylist of the runtime chains that include the channel
19876
public synchronized List<ChainData> getRunningChains(ChannelDataImpl parent) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "getRunningChains");
        }
        ChannelContainer channelContainer = null;
        List<ChainData> chainDataList = new ArrayList<ChainData>();

        // Iterate the children - they are in the runtime.
        Iterator<ChildChannelDataImpl> children = parent.children();
        while (children.hasNext()) {
            // Get the runtime channel container for this child.
            channelContainer = this.channelRunningMap.get(children.next().getName());
            for (Chain chain : channelContainer.getChainMap().values()) {
                chainDataList.add(chain.getChainData());
            }
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "getRunningChains: " + chainDataList.size());
        }
        return chainDataList;
    }
1263824
public DataDescriptor parentDescriptor() {
        if (type == TYPE_INVALID) {
            return null;
        } else if (dataIds != null) {
            return new DataDescriptor(dataPath);
        } else {
            if (dataPath.length == 1)
                return null;
            String[] myPath = new String[dataPath.length - 1];
            System.arraycopy(dataPath, 0, myPath, 0, myPath.length);
            return new DataDescriptor(myPath);
        }
    }
54933
public static Stream<Node> stream(Node parent) {
        if (parent == null) {
            return Stream.empty();
        } else {
            return StreamSupport.stream(spliteratorUnknownSize(iterator(parent), 0), false);
        }
    }
410683
public static Iterator<Element> iterator(Element parent) {
        return parent != null ? new ChildrenIterator(parent) : Collections.<Element>emptyList().iterator();
    }
585923
public static List<XmlChannel> toCollectionXmlChannels(Collection<Channel.Builder> channelBuilders) {
		List<XmlChannel> xmlchannels = new ArrayList<XmlChannel>();
		for (Channel.Builder builder : channelBuilders) {
			xmlchannels.add(builder.toXml());
		}
		return xmlchannels;
	}
262310
def parents(self) -> List["Collection"]:
        
        p = self.parent
        parents = []
        while p is not None:
            parents.append(p)
            p = p.parent
        return parents
1208816
@Override
    public synchronized ChainData[] getAllChains(String channelName) throws ChannelException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "getAllChains: " + channelName);
        }
        if (null == channelName) {
            throw new InvalidChannelNameException("Null channelName found");
        }

        ChainDataImpl chainData = null;
        List<ChainData> chainDataList = new ArrayList<ChainData>();

        // Collect all chains referring to the channel
        Iterator<ChainDataImpl> chainDataIter = chainDataMap.values().iterator();
        while (chainDataIter.hasNext()) {
            chainData = chainDataIter.next();
            if (chainData.containsChannel(channelName)) {
                chainDataList.add(chainData);
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "getAllChains");
        }
        return chainDataList.toArray(new ChainData[chainDataList.size()]);
    }
94961
public List<Runner> runners(Class<?> parent, Class<?>[] children)
            throws InitializationError {
        addParent(parent);

        try {
            return runners(children);
        } finally {
            removeParent(parent);
        }
    }
387941
private List<Entry> getChildNodes(DirectoryEntry parent)
   {
      List<Entry> result = new ArrayList<Entry>();
      Iterator<Entry> entries = parent.getEntries();
      while (entries.hasNext())
      {
         result.add(entries.next());
      }
      return result;
   }
235280
def get_parent_bank_nodes(self):
        
        parent_bank_nodes = []
        for node in self._my_map['parentNodes']:
            parent_bank_nodes.append(BankNode(
                node._my_map,
                runtime=self._runtime,
                proxy=self._proxy,
                lookup_session=self._lookup_session))
        return BankNodeList(parent_bank_nodes)
128938
public Set<ClassDescriptor> getDirectSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {

        ClassVertex startVertex = resolveClassVertex(classDescriptor);

        Set<ClassDescriptor> result = new HashSet<>();
        Iterator<InheritanceEdge> i = graph.incomingEdgeIterator(startVertex);
        while (i.hasNext()) {
            InheritanceEdge edge = i.next();
            result.add(edge.getSource().getClassDescriptor());
        }

        return result;
    }
38504
public static Class getGenericClassFromParent(Object parent) {
		return (Class) ((ParameterizedType) parent.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
	}
1011479
public ArrayList getTreePerfLevelDescriptors(int parentLevel) {
        ArrayList res = new ArrayList();
        int thisLevel = level;
        if (instance == null) { // should be root
            res.add(new PerfLevelDescriptor(new String[] { "pmi" }, thisLevel));
        } else {
            PmiModule instance = getInstance();
            thisLevel = instance.getInstrumentationLevel();
            // if the level is same as parent, do not add to the list
            if ((thisLevel != LEVEL_UNDEFINED) && (thisLevel != parentLevel)) {
                res.add(new PerfLevelDescriptor(instance.getPath(), thisLevel, instance.getModuleID()));
            }
        }

        // get from children
        ModuleItem[] items = children();
        if (items == null)
            return res;
        for (int i = 0; i < items.length; i++) {
            ArrayList childrenLevels = items[i].getTreePerfLevelDescriptors(thisLevel);
            for (int j = 0; j < childrenLevels.size(); j++)
                res.add(childrenLevels.get(j));
        }
        return res;
    }
1292573
private long getFrequentItemsets(PrintStream out, List<ItemSet> list) {
        long n = 0;
        if (root.children != null) {
            for (int i = 0; i < root.children.length; i++) {
                Node child = root.children[i];
                if (child != null && child.support >= minSupport) {
                    int[] itemset = {child.id};
                    n += getFrequentItemsets(out, list, itemset, i, child);
                }
            }
        }
        
        return n;
    }
337754
public Operation getSimplifiedJoinOp(Mapper mapper, List parentList)
    {
        int maxSimplifiedIn = DeepRelationshipUtility.MAX_SIMPLIFIED_IN;
        boolean differentPersisterThanParent = differentPersisterIdThanParent(mapper);
        if (differentPersisterThanParent)
        {
            maxSimplifiedIn = Integer.MAX_VALUE;
        }
        return mapper.getSimplifiedJoinOp(parentList, maxSimplifiedIn, this, differentPersisterThanParent);
    }
482230
static <T> List<T> getFilteredChildren(ParentRunner<T> parentRunner) {
    try {
      //noinspection unchecked
      return new ArrayList<>((Collection<T>) getFilteredChildrenMethod.invoke(parentRunner));
    } catch (IllegalAccessException | InvocationTargetException e) {
      throw new RuntimeException("Failed to invoke getFilteredChildren()", e);
    }
  }
550061
public List<Entry> getDirectChildren(Dn parent) throws NoSuchNodeException, MissingParentException {
        return extractEntriesFromCursor(searchOneLevel(parent));
    }