Recursively get all spContainers within this spgrContainer

@return PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer[]
164426
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;
	}
980080
public function listContainers($include_properties = false)
    {
        $this->checkConnection();

        if (!empty($this->container)) {
            return $this->listResource($include_properties);
        }

        try {
            /** @var Collection $containers */
            $containers = $this->blobConn->ContainerList();

            $out = [];

            /** @var Container $container */
            while (($container = $containers->Next())) {
                $name = rtrim($container->name);
                $out[] = ['name' => $name, 'path' => $name];
            }

            return $out;
        } catch (\Exception $ex) {
            static::handleGuzzleException($ex);
            throw new DfException('Failed to list containers: ' . $ex->getMessage());
        }
    }
1028962
public function getAll(): array
    {
        $response = $this->client->request('GET', $this->client->getConfig('base_uri') . '/shared-links/');

        $json = json_decode($response->getBody());

        $sharedLinksCollection = [];

        foreach ($json->fileshares as $sharedLink) {
            $sharedLinksCollection[] = (new SharedLinkType)->fromJson($sharedLink);
        }

        return $sharedLinksCollection;
    }
481774
public function getClassNamesForContainer()
    {
        $classes = [$this->owner->isFullWidth() ? 'container-fluid' : 'container'];
        
        if ($this->owner->isEdgeToEdge()) {
            $classes[] = $this->style('section.edge-to-edge');
        }
        
        return $classes;
    }
264777
public function getLists()
    {
        $returnValue = array();

        
        
        $returnValue[] = new core_kernel_classes_Class(GenerisRdf::GENERIS_BOOLEAN);
        
        foreach($this->parentListClass->getSubClasses(false) as $list){
        	$returnValue[] = $list;
        }
        
        
        
        

        return (array) $returnValue;
    }
720939
public function findAll()
    {
        $appNodes = array();
        foreach ($this->getSystemConfiguration()->getApps() as $appNode) {
            $appNodes[$appNode->getPrimaryKey()] = $appNode;
        }
        return $appNodes;
    }
1189707
public function getAll()
    {
        $fields = $this->fields;
        $cacheControlHeader = $this->getCacheControlHeader();
        $fields['Cache-Control'] = [$cacheControlHeader];
        if (empty($cacheControlHeader)) {
            unset($fields['Cache-Control']);
        }
        return $fields;
    }
440643
public function getBundles()
    {
        $bundles = [];
        foreach ($this->getContainer()->findTaggedServiceIds('bundle') as $id => $datas) {
            $bundles[] = $this->getContainer()->get($id);
        }

        return $bundles;
    }
1214916
public function getAllCategoryTreesAsArray()
    {
        $rootIds = $this->getAllRootIds();

        $trees = array();
        foreach ($rootIds as $rootId) {
            $trees[$rootId] = $this->getCategoryTreeAsArray($rootId);
        }

        return $trees;
    }
292339
public function getAll() {
        if (!$this->finalized) $this->autoFinalize();
        $ret = array();
        foreach ($this->plist->squash() as $name => $value) {
            list($ns, $key) = explode('.', $name, 2);
            $ret[$ns][$key] = $value;
        }
        return $ret;
    }
565247
public function all()
    {
        $this->recursionCounter++;

        if ($this->recursionCounter <= static::$recursionLimit) {
            return array_map(function ($value) {
                return is_callable($value) ? $value() : $value;
            }, $this->data);
        }

        return [];
    }
1060639
public function findAll()
    {
        $deploymentNodes = array();
        foreach ($this->getSystemConfiguration()->getContainers() as $container) {
            $deploymentNode = $container->getDeployment();
            $deploymentNodes[$deploymentNode->getUuid()] = $deploymentNode;
        }
        return $deploymentNodes;
    }
96242
@Override
    public IAtomContainer[] getFragmentsAsContainers() {
        List<IAtomContainer> allfrags = new ArrayList<IAtomContainer>();
        allfrags.addAll(frameMap.values());
        allfrags.addAll(ringMap.values());
        return allfrags.toArray(new IAtomContainer[0]);
    }
1270711
public function getAll(): array
    {
        $this->rewind();
        $allValues = [];
        while ($this->valid()) {
            $allValues[] = $this->getCurrentElement()->getValue();
            $this->next();
        }
        return $allValues;
    }
1321378
public function getPossibleParents() {
    $result = [];
    $relations = $this->getRelations('parent');
    foreach ($relations as $curRelation) {
      $result[$curRelation->getOtherRole()] = $curRelation;
    }
    return $result;
  }
163230
protected function getChildrenList() {
        $query = (new Query)->from($this->itemChildTable);
        $parents = [];
        foreach ($query->all($this->db) as $row) {
            $parents[$row['parent']][] = $row['child'];
        }
        return $parents;
    }
1079814
public function getWroteBlocks()
    {
        if (!is_dir($this->blocks)) {
            throw new RuntimeException("cannot obtain the blocks ({$this->blocks})");
        }
        $files = array_filter(array_map(function($file) {
            $basename = basename($file);
            if (!is_numeric($basename)) {
                return false;
            }
            return [
                'offset' => (int)$basename,
                'file' => $file,
                'size' => filesize($file)
            ];
        }, glob($this->blocks . "*")));

        uasort($files, function($a, $b) {
            return $a['offset'] - $b['offset'];
        });

        return $files;
    }