Override to return the top level content items from the remote
content source.

Specific implementations should effectively query the remote
source for all items that are children of the 'root' node.

@param boolean $showAll
@return DataObjectSet
501281
public function stageChildren($showAll = false) {
		// if we don't have an ID directly, we should load and return ALL the external content sources
		if (!$this->ID) {
			return DataObject::get('ExternalContentSource');
		}

		$children = new ArrayList();
		return $children;
	}
147217
public function all($affiliateFid = null, $showPending = null)
  {
    $payload = new ListPixelPayload();
    $payload->affiliateFid = $affiliateFid;
    $payload->showPending = $showPending;

    $ep = AffiliatePixelEndpoint::bound($this->getApi());
    return $ep->all($payload)->get();
  }
870901
private function getAllSetData()
    {
        $data = $this->mappedProperties();
        if (isset($data['address'])) {
            $address = $data['address'];
            unset(
                $data['address']
            );

            $data = array_merge($data, $address);
        }

        return $data;
    }
995350
public function getAllRootCategories($loadChildren = true)
    {
        $class = $this->getClass();

        $rootCategories = $this->getObjectManager()->createQuery(sprintf('SELECT c FROM %s c WHERE c.parent IS NULL', $class))
            ->execute();

        $categories = [];

        foreach ($rootCategories as $category) {
            if (null === $category->getContext()) {
                throw new \RuntimeException('Context cannot be null');
            }

            $categories[] = $loadChildren ? $this->getRootCategoryWithChildren($category) : $category;
        }

        return $categories;
    }
1040575
public static function defines($showAll = false)
    {
        if (!self::isDebug()) {
            return false;
        }

        $defines = get_defined_constants(true);
        if (!$showAll) {
            $defines = (isset($defines['user'])) ? $defines['user'] : array();
        }

        return self::i()->dump($defines, '! defines !');
    }
737596
public function AllSuccessArray() {
        $r=array();
        foreach($this->items as $v) {
            $r=array_merge($r,$v->allSuccess());
        }
        return $r;
    }
505846
public static function getNodesToOpen($uris, core_kernel_classes_Class $rootNode) {
        // this array is in the form of
        // URI to test => array of uris that depend on the URI
        $toTest = array();
        foreach($uris as $uri){
            $resource = new core_kernel_classes_Resource($uri);
            foreach ($resource->getTypes() as $type) {
                $toTest[$type->getUri()] = array();
            }
        }
        $toOpen = array($rootNode->getUri());
        while (!empty($toTest)) {
            reset($toTest);
            $classUri = key($toTest);
            $depends = current($toTest);
            unset($toTest[$classUri]);
            if (in_array($classUri, $toOpen)) {
                $toOpen = array_merge($toOpen, $depends);
            } else {
                $class = new core_kernel_classes_Class($classUri);
                /** @var core_kernel_classes_Class $parent */
                foreach ($class->getParentClasses(false) as $parent) {
                    if ($parent->getUri() === OntologyRdfs::RDFS_CLASS) {
                        continue;
                    }
                    if (!isset($toTest[$parent->getUri()])) {
                        $toTest[$parent->getUri()] = array();
                    }
                    $toTest[$parent->getUri()] = array_merge(
                        $toTest[$parent->getUri()],
                        array($classUri),
                        $depends
                    );
                }
            }
        }
        return $toOpen;
    }
760660
public function getAll(){
        $rest = $this->getService( self::API_SHARE_LINK);
        $rest->GET();

        return $rest->getResultAsArray( models\FileSystem\ShareLink::class);
    }
83897
public function getChildComponents($all = false)
    {
        if ($all == false) {
            return $this->components;
        }

        $list = array();
        foreach ($this->components as $component) {
            $list[] = $component;

            if ($component instanceof HtmlContainer) {
                $childs = $component->getChildComponents(true);
                foreach ($childs as $child) {
                    $list[] = $child;
                }
                //array_push($list,$component->getChildComponents(true));
            }
        }
        return $list;
    }
293647
function getAllCollections() {
  return getAllItems()
    .then(items => _.flatten(
      items.map(item => {
        return item.dataset.map(coll => {
          coll.instance = item.id;
          return coll;
        });
      })
    ));
}
1233405
public function getAllChildren(&$children = [])
    {
        if (!$this->allChildren && $this->getChildren()) {
            $page = $this;
            foreach ($page->getChildren() as $child) {
                $children[] = $child;
                if ($child->getChildren()) {
                    $child->getAllChildren($children);
                }
            }

            $this->setAllChildren(array_reverse($children));
        }

        return $this->allChildren;
    }
928107
public function tree($rootId = NULL){
        if($rootId === NULL){
            $rootId = '__root';
        }

        if(!isset($this->_rootNodeCache[$rootId])){

            $result = $this->getHierarchyByRootIdQuery($rootId)
                           ->get($this->getSelectColumns());

            $this->fillNodeCache($result);

            Helper::toHierarchy($result);

        }

        return $this->_rootNodeCache[$rootId];
    }
590303
public function children($depth = false)
    {
        return $this->menu->whereParentId($this->id, $depth)->all();
    }
286318
@Override
    public Object[][] getAllData() {
        logger.entering();
        Object[][] objectArray;

        if ((null == resource.getCls()) && (null != resource.getXpathMap())) {
            Document doc = getDocument();
            Object[][][] multipleObjectDataProviders = new Object[resource.getXpathMap().size()][][];
            int i = 0;
            for (Entry<String, Class<?>> entry : resource.getXpathMap().entrySet()) {
                String xml = getFilteredXml(doc, entry.getKey());
                List<?> object = loadDataFromXml(xml, entry.getValue());
                Object[][] objectDataProvider = DataProviderHelper.convertToObjectArray(object);
                multipleObjectDataProviders[i++] = objectDataProvider;
            }
            objectArray = DataProviderHelper.getAllDataMultipleArgs(multipleObjectDataProviders);
        } else {
            List<?> objectList = loadDataFromXmlFile();
            objectArray = DataProviderHelper.convertToObjectArray(objectList);
        }

        // Passing no arguments to exiting() because implementation to print 2D array could be highly recursive.
        logger.exiting();
        return objectArray;
    }
291798
public function getAllSpContainers()
    {
        $allSpContainers = array();

        foreach ($this->children as $child) {
            if ($child instanceof PHPExcel_Shared_Escher_DgContainer_SpgrContainer) {
                $allSpContainers = array_merge($allSpContainers, $child->getAllSpContainers());
            } else {
                $allSpContainers[] = $child;
            }
        }

        return $allSpContainers;
    }
506768
public function getChildren($id, bool $all = false): Collection
    {
        if (! $all) {
            return $this->repo->pushCriteria(new GetChildren($id))->all();
        } else {
            return $this->repo->pushCriteria(new GetChildAll($id))->all();
        }
    }
936369
protected function getMethods($showAll, \Reflector $reflector, $noInherit = false)
    {
        $className = $reflector->getName();

        $methods = [];
        foreach ($reflector->getMethods() as $name => $method) {
            if ($noInherit && $method->getDeclaringClass()->getName() !== $className) {
                continue;
            }

            if ($showAll || $method->isPublic()) {
                $methods[$method->getName()] = $method;
            }
        }

        \ksort($methods, SORT_NATURAL | SORT_FLAG_CASE);

        return $methods;
    }