Returns all collection.

@param boolean $wrap whether to wrap the collection instances in Collection classes.

@return array connections array
480582
public function allCollections($wrap = false)
    {
        $collections = $this->database->listCollections();

        if (! $wrap) {
            return $collections;
        }

        return array_map(
            function ($collection) {
                return new Collection($collection);
            },
            $collections
        );
    }
1111526
public function values($collection=null) {
    list($collection) = self::_wrapArgs(func_get_args(), 1);
    
    return self::_wrap(array_values((array) $collection));
  }
1140871
protected function retrieveCollection()
    {
        $cache = new FilesystemAdapter($this->namespace);
        $item = $cache->getItem('collection');

        $collection = null;
        if ($item->isHit()) {
            $collection = $item->get('collection');
        }

        if (empty($collection) || !$collection instanceof ValuesCollection) {
            $collection = new ValuesCollection();
        }

        return $collection;
    }
281302
public function findAllJoinPage(bool $refresh = FALSE) : ObjectCollection
    {
        if (!$this->allPageUrlJoinPage || $refresh)
        {
            $this->allPageUrlJoinPage = PageUrlQuery::create()
                ->joinWithPage()
                ->usePageQuery()
                    ->filterByTreeLevel(['min' => 2])
                ->endUse()
                ->orderByUrl()
                ->find();
        }

        return $this->allPageUrlJoinPage;
    }
931349
final public function findAll()
    {
        $this->query->setStartSelect();

        $this->query->prepare()->bindWhere()->bindLimit()->execute();

        $this->setRowCount();

        $collection = new Collection($this, $this->query->getSqlQuery());

        $this->query->close();

        return $collection();
    }
349399
public function getQueries($boolType = null)
    {
        if ($boolType === null) {
            $queries = [];

            foreach ($this->container as $item) {
                $queries = array_merge($queries, $item);
            }

            return $queries;
        }

        if (isset($this->container[$boolType])) {
            return $this->container[$boolType];
        }

        return [];
    }
591889
public function getList(array $types = [])
    {
        if (!$types || $types == StorageEntity::getTypes()) {
            return $this->getEntityManager()->createQuery('
                SELECT
                    s
                FROM
                    AnimeDbCatalogBundle:Storage s
                ORDER BY
                    s.id DESC
            ')->getResult();
        }

        return $this->getEntityManager()->createQuery('
            SELECT
                s
            FROM
                AnimeDbCatalogBundle:Storage s
            WHERE
                s.type IN (:types)
            ORDER BY
                s.id DESC
        ')
            ->setParameter(':types', $types)
            ->getResult();
    }
684161
protected function _collection()
    {
        if (!isset($this->_collections[$this->_collection])) {
            $this->_collections[$this->_collection] = new $this->_collectionClass($this);
        }

        return $this->_collections[$this->_collection];
    }
16781
public function getAll()
    {
        if (!$this->getResource()) {
            return [];
        }
        if ($this->useLocalResource) {
            return $this->localResource;
        }

        // If we're attempting to use a global resource but it doesn't exist, we've got a problem.
        if (!isset($GLOBALS[$this->getResource()])) {
            throw new \Parable\GetSet\Exception(
                "Attempting to use global resource '{$this->getResource()}' but resource not available."
            );
        }

        return $GLOBALS[$this->getResource()];
    }
797975
public function getCollection()
    {
        $queueDatabase = $this->database;
        $queueResource = $this->collection;
        $db = $this->getAdapter();

        return $db->$queueDatabase->$queueResource;
    }
782128
public function getAll($params = [])
    {
        $result = $this->connection()->get($this->getEndpoint(), $params, true);

        return $this->collectionFromResult($result);
    }
852486
public function getCollectionData()
    {
        $returnList = array();
        switch( $this->ContentObjectAttribute->attribute( 'data_type_string' ) )
        {
            case 'ezobjectrelation':
            {
                $returnList = $this->getBaseList( $this->ContentObjectAttribute->attribute( 'object_version' ) );
            } break;

            case 'ezobjectrelationlist':
            {
                $content = $this->ContentObjectAttribute->content();
                foreach ( $content['relation_list'] as $relationItem )
                {
                    $subObjectID = $relationItem['contentobject_id'];
                    if ( !$subObjectID )
                        continue;
                    $subObject = eZContentObjectVersion::fetchVersion( $relationItem['contentobject_version'], $subObjectID );
                    if ( !$subObject )
                        continue;

                    $returnList = array_merge( $this->getBaseList( $subObject ),
                                               $returnList );
                }
            } break;
        }

        return $returnList;
    }
516828
public function getCollections()
    {
        if ($this->collections) {
            return $this->collections;
        }

        $collectionMapper = ($this->container->dataMapper)('CollectionMapper');

        return $this->collections = $collectionMapper->find();
    }
872520
public function getConnectorsAsArray()
    {
        // Iterate over the connectors nodes and sort them into an array
        $connectors = array();
        /** @var \AppserverIo\Appserver\Core\Api\Node\ConnectorNode $connectorNode */
        foreach ($this->getConnectors() as $connectorNode) {
            // Restructure to an array
            $connectors[] = array(
                'name' => $connectorNode->getName(),
                'type' => $connectorNode->getType(),
                'params' => $connectorNode->getParamsAsArray()
            );
        }

        // Return what we got
        return $connectors;
    }
1321848
public function values(): CollectionInterface
    {
        return $this->wrap(function (Iterator $data) {
            foreach ($data as $item) {
                yield $item;
            }
        });
    }
903401
public static function getList()
    {
        $app = Facade::getFacadeApplication();
        $db = $app->make('database')->connection();
        $libraries = [];
        foreach ($db->fetchAll('select sclHandle from SystemCaptchaLibraries order by sclHandle asc') as $row) {
            $scl = static::getByHandle($row['sclHandle']);
            $libraries[] = $scl;
        }

        return $libraries;
    }
789339
public function getConnectionsAttribute()
    {
        $response = $this->discord->request(
            'GET',
            $this->discord->getConnectionsEndpoint(),
            $this->token
        );

        $collection = new Collection();

        foreach ($response as $raw) {
            $collection->push(
                $this->discord->buildPart(Connection::class, $this->token, $raw)
            );
        }

        return $collection;
    }