Fetch all the queues inside the 'queues' namespace with the delayed and
reserved.

@return \Illuminate\Support\Collection
324520
public function getAll()
	{
		$collection = new Collection;

		$keys = $this->database->keys($this->namespace.':*');

		foreach ($keys as $key)
		{
			list($namespace, $name) = explode(':', $key);

			if ( ! $collection->has($name))
			{
				$collection->put($name, $this->get($name));
			}
		}

		return $collection;
	}
772300
public function getAllServices()
    {
        $result = array();
        foreach ($this->getExtensions() as $handle) {
            $result[$handle] = $this->getService($handle);
        }

        return $result;
    }
1209304
public function collections()
    {
        $uri = $this->uri->withPath($this->uri->getPath() . ':listCollectionIds');
        $value = $this->client->post($uri, null);
        $collections = [];

        foreach ($value['collectionIds'] as $id) {
            $collections[] = $this->collection($id);
        }

        return $collections;
    }
227216
public function getStoresForFrontend()
    {
        $collection = $this->stockistsCollectionFactory->create()
            ->addFieldToSelect('*')
            ->addFieldToFilter('store_id', $this->getStoreId())
            ->addFieldToFilter('status', Stores::STATUS_ENABLED)
            ->setOrder('name', 'ASC');
        return $collection;
    }
420574
protected function proxy() {
        if (!$this->context) {
            $this->context = new QueueContext(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['sid']
            );
        }

        return $this->context;
    }
210466
public static function getNamespaces()
    {
        $called = get_called_class();

        if (!isset(static::$namespaces[$called])) {
            static::$namespaces[$called] = new PriorityQueue();
        }

        return static::$namespaces[$called];
    }
572247
public function get()
    {
        $processes = $this->processes();

        return collect($this->waitTime->calculate())
            ->map(function ($waitTime, $queue) use ($processes) {
                [$connection, $queueName] = explode(':', $queue, 2);

                $length = ! Str::contains($queue, ',')
                    ? $this->queue->connection($connection)->readyNow($queueName)
                    : collect(explode(',', $queueName))->sum(function ($queueName) use ($connection) {
                        return $this->queue->connection($connection)->readyNow($queueName);
                    });

                return [
                    'name' => $queueName,
                    'length' => $length,
                    'wait' => $waitTime,
                    'processes' => $processes[$queue] ?? 0,
                ];
            })->values()->toArray();
    }
516828
public function getCollections()
    {
        if ($this->collections) {
            return $this->collections;
        }

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

        return $this->collections = $collectionMapper->find();
    }
1222640
public function getQueueableIds()
    {
        if ($this->isEmpty()) {
            return [];
        }

        return $this->first() instanceof QueueableEntity
                    ? $this->map->getQueueableId()->all()
                    : $this->modelKeys();
    }
609121
public function queueInfo()
    {
        if ($this->queueExists()) {
            $queueName = $this->getNameWithPrefix();
            $this->queue = $this->ironmq->getQueue($queueName);

            return $this->queue;
        }

        return null;
    }
1154515
public function getIterator()
    {
        if (null === $this->queue) {
            $this->queue = new SplPriorityQueue();
            $this->queueOrder = 0;
            foreach (parent::getIterator() as $filter) {
                $this->queue->insert(
                    $filter,
                    array($this->priorities[$filter->getName()], $this->queueOrder--)
                );
            }
        }
        return clone $this->queue;
    }
797975
public function getCollection()
    {
        $queueDatabase = $this->database;
        $queueResource = $this->collection;
        $db = $this->getAdapter();

        return $db->$queueDatabase->$queueResource;
    }
147170
public function getQueries()
    {
        return array_merge(
            $this->createNamespaceQueries,
            $this->createTableQueries,
            $this->createSequenceQueries,
            $this->createFkConstraintQueries
        );
    }
852907
public function getQueue()
    {
        $this->queue = array_values(array_diff(array_unique(array_merge($this->queue, array_keys($this->sitemaps))), $this->history));
        return $this->queue;
    }
332118
public function getQueuedAttachments()
    {
        $queued = [];

        foreach ($this->getMediaFiles() as $name => $attachment) {
            if ($attachment->isQueued()) {
                $queued[$name] = $attachment;
            }
        }

        return $queued;
    }
1367458
public function getListQueued()
    {
        $params = ['status' => 'queued'];

        $response = $this->client->fetch(
            $this->uri,
            $params
        );

        $queuedCallUuids = $response->getContent()['calls'];

        return $queuedCallUuids;
    }
1083848
public function all()
	{
		$callback = $this->connection->executeSelect($this->toSql(), ['12']);

		$start =   time() + microtime(true);

		$statement = $callback();

		$delay = time() + microtime(true) - $start;

		$items = $statement->fetchAll(PDO::FETCH_OBJ);

		$collection = new Collection($items, (count($items) > 0 ? array_keys((array)$items[0]) : []), $delay);

		return $collection;
	}