Loads the children, caching the results in the children ivar.
349514
public Object[] getChildren() {
        if (children != null) {
            return children;
        }
        if (this.isTestcaseDir()) {
            try {
                ArrayList<TestDataNode> arrayDataNode = new ArrayList<>();
                // load test case data
                File tcDataFile = this.getPythonTestScript().getTestcaseData();
                if (tcDataFile == null) {
                    return new Object[] {};
                }
                CSVFile csvDataFile = new CSVFile(tcDataFile);
                List<LinkedHashMap<String, String>> data = csvDataFile.getCSVDataSet();
                Iterator<LinkedHashMap<String, String>> it = data.iterator();
                int rowIndex = 1;
                while (it.hasNext()) {
                    LinkedHashMap<String, String> dataRow = it.next();
                    if (dataRow.containsKey("COMMENT")) {
                        String comment = dataRow.get("COMMENT");
                        arrayDataNode.add(new TestDataNode(tcDataFile, comment, rowIndex));
                    }
                    rowIndex++;
                }
                children = arrayDataNode.toArray();
                return children;
            } catch (IOException ex) {
                // unable to read data file

            }

        } else {
            ArrayList<FileNode> arrayFileNode = new ArrayList<>();
            if (f.isDirectory()) {
                File[] childFiles = FileUtilities.listSortedFiles(f);
                for (File childFile : childFiles) {
                    FileNode fn = new FileNode(childFile, childFile.getName(), m_TestSuiteDir);
                    boolean nodeToAdd = fn.isTestcaseDir();
                    if (!fn.isTestcaseDir()) {
                        // go recursilvely to its child and check if it must be added
                        nodeToAdd = checkIfDirectoryContainsTestScriptFile(childFile);
                    }
                    if (nodeToAdd && !childFile.isHidden()) {

                        arrayFileNode.add(fn);
                    }
                }
            }
            children = arrayFileNode.toArray();
        }
        if (children == null) {
            return new Object[] {};
        } else {
            return children;
        }
    }
582267
function _cacheChildren(node) {
  var children = node.get('children');
  if(children) {
    node.set('allChildren', children);
    children.forEach(_cacheChildren);
  }
}
289508
private static final void loadResources(final CClassLoader loader,
			final List URLList, final String resourceName) {
		final List l = loader.getPrivateResource(resourceName);

		if (l != null) {
			URLList.addAll(l);
		}

		final List loaderList = new ArrayList();

		for (final Iterator it = loader.childrenMap.entrySet().iterator(); it
				.hasNext();) {
			final Entry entry = (Entry) it.next();
			loaderList.add(entry.getValue());
		}

		for (int i = 0; i < loaderList.size(); i++) {
			final Object element = loaderList.get(i);
			final CClassLoader child = (CClassLoader) element;
			CClassLoader.loadResources(child, URLList, resourceName);
		}
	}
498098
def set_children(self, children):
        """"""
        if isinstance(children, tuple):
            self._children = list(children)
        else:
            self._children = [children]
        return self
143543
protected function loadAssetsCache()
    {
        $cachedFiles = $this->cachedFilesObjectBackend->loadObject();
        if (!is_array($cachedFiles)) {
            $cachedFiles = array();
        }
        
        $this->cachedFiles = $cachedFiles;
    }
597852
public function loadCacheDetails()
    {
        $cacheFile = md5($this->url);
        $this->fileName = $this->saveFolder . $cacheFile;
        $this->fileJson = $this->fileName . ".json";
        if (is_readable($this->fileJson)) {
            $this->cache = json_decode(file_get_contents($this->fileJson), true);
        }
    }
132284
private List<Type> getAllChildTypes(final Type _parent)
        throws CacheReloadException
    {
        final List<Type> ret = new ArrayList<>();
        for (final Type child : _parent.getChildTypes()) {
            ret.addAll(getAllChildTypes(child));
            ret.add(child);
        }
        return ret;
    }
656795
public void setChildren(java.util.Collection<Child> children) {
        if (children == null) {
            this.children = null;
            return;
        }

        this.children = new java.util.ArrayList<Child>(children);
    }
345509
def recursive_children(self):
        

        for child in self.children:
            yield child

            for recursive_child in child.recursive_children:
                yield recursive_child
1174114
private function load()
    {
        if (null === $this->collection) {
            $this->collection = $this->transformer->getChildren($this->page);
        }
    }
1296316
def __load_child_classes(self, ac: AssetClass):
        
        # load child classes for ac
        db = self.__get_session()
        entities = (
            db.query(dal.AssetClass)
            .filter(dal.AssetClass.parentid == ac.id)
            .order_by(dal.AssetClass.sortorder)
            .all()
        )
        # map
        for entity in entities:
            child_ac = self.__map_entity(entity)
            # depth
            child_ac.depth = ac.depth + 1
            ac.classes.append(child_ac)
            # Add to index
            self.model.asset_classes.append(child_ac)

            self.__load_child_classes(child_ac)
1109520
private static Set<Type> getChildTypes(final Type _type)
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<Type>();
        ret.add(_type);
        for (final Type child : _type.getChildTypes()) {
            ret.addAll(getChildTypes(child));
        }
        return ret;
    }
1100562
private void processChildren( List<RemovrSpec> children, Object subInput ) {

        if (subInput != null ) {

            if( subInput instanceof List ) {

                List<Object> subList = (List<Object>) subInput;
                Set<Integer> indiciesToRemove = new HashSet<>();

                // build a list of all indicies to remove
                for(RemovrSpec childSpec : children) {
                    indiciesToRemove.addAll( childSpec.applyToList( subList ) );
                }

                List<Integer> uniqueIndiciesToRemove = new ArrayList<>( indiciesToRemove );
                // Sort the list from Biggest to Smallest, so that when we remove items from the input
                //  list we don't muck up the order.
                // Aka removing 0 _then_ 3 would be bad, because we would have actually removed
                //  0 and 4 from the "original" list.
                Collections.sort( uniqueIndiciesToRemove, new Comparator<Integer>() {
                    @Override
                    public int compare( Integer o1, Integer o2 ) {
                        return o2.compareTo( o1 );
                    }
                } );

                for ( int index : uniqueIndiciesToRemove ) {
                    subList.remove( index );
                }
            }
            else if (subInput instanceof Map ) {

                Map<String,Object> subInputMap = (Map<String,Object>) subInput;

                List<String> keysToRemove = new LinkedList<>();

                for(RemovrSpec childSpec : children) {
                    keysToRemove.addAll( childSpec.applyToMap( subInputMap ) );
                }

                subInputMap.keySet().removeAll( keysToRemove );
            }
        }
    }
929755
def children(self):
        
        for child in self.data.get('children', []):
            if osp.exists(osp.join(self.path, child, YAML_REPORT_FILE)):
                yield child, self.__class__(osp.join(self.path, child))
979388
public function loadFromCache()
    {
        if ($this->items !== null || !$this->cache instanceof Cache) {
            return;
        }

        $data = $this->cache->get($this->cacheKey);
        if (is_array($data) && isset($data[0], $data[1])) {
            list ($this->items, $this->rules) = $data;
            return;
        }

        $query = (new Query)->from($this->itemCollection);
        $this->items = [];
        foreach ($query->all($this->db) as $row) {
            $this->items[$row['name']] = $this->populateItem($row);
        }

        $query = (new Query)->from($this->ruleCollection);
        $this->rules = [];
        foreach ($query->all($this->db) as $row) {
            $this->rules[$row['name']] = unserialize($row['data']);
        }

        $this->cache->set($this->cacheKey, [$this->items, $this->rules]);
    }
393251
public function setAllLoaded()
	{
		$this->_allChildrenloaded = true;

		foreach ($this->_children as $child)
		{
			$child->setAllLoaded();
		}
	}
482084
def load_children(self, f):
        """"""
        while True:
            line = self.readline(f)
            if line[0] == '&':
                if line[1:].startswith("END"):
                    check_name = line[4:].strip().upper()
                    if check_name != self.__name:
                        raise FileFormatError("CP2KSection end mismatch, pos=%s", f.tell())
                    break
                else:
                    section = CP2KSection()
                    section.load(f, line)
                    self.append(section)
            else:
                keyword = CP2KKeyword()
                keyword.load(line)
                self.append(keyword)