Returns array (id => name) of all tracks, sorted alphabetically
@return array
320398
public function getAllTracks()
    {
        $cacheId = __CLASS__ . '_' . __FUNCTION__;

        if ($results = $this->cache->load($cacheId)) {
            return $results;
        }

        $select = "SELECT gtr_id_track, gtr_track_name
                    FROM gems__tracks
                    WHERE gtr_track_class != 'SingleSurveyEngine'
                    ORDER BY gtr_track_name";

        $results = $this->db->fetchPairs($select);
        $this->cache->save($results, $cacheId, array('tracks'));
        return $results;
    }
227006
public function getDiscounts()
    {
        if ($this->getTotalDiscount() && $this->getTotalDiscount()->getBruttoPrice() == 0 && count($this->_aItemDiscounts) == 0) {
            return [];
        }

        return array_merge($this->_aItemDiscounts, $this->_aDiscounts);
    }
526109
protected function getIDListFromDB() : array
    {
        switch ($this->sValue) {
            case PromoBlockListStore::SORT_DATE_BEGIN_ASC:
                $arElementIDList = $this->getByDateBeginASC();
                break;
            case PromoBlockListStore::SORT_DATE_BEGIN_DESC:
                $arElementIDList = $this->getByDateBeginDESC();
                break;
            case PromoBlockListStore::SORT_DATE_END_ASC:
                $arElementIDList = $this->getByDateEndASC();
                break;
            case PromoBlockListStore::SORT_DATE_END_DESC:
                $arElementIDList = $this->getByDateEndDESC();
                break;
            case PromoBlockListStore::SORT_DEFAULT:
                $arElementIDList = $this->getBySortOrder();
                break;
            default:
                $arElementIDList = $this->getCustomSortingList();
                break;
        }

        return $arElementIDList;
    }
519205
public function getSingleRecords()
    {
        $singleRecords = [];
        $singleRecordUids = GeneralUtility::intExplode(',', $this->conf['singleSelection'], true);
        $pids = GeneralUtility::intExplode(',', $this->conf['pidList'], true);

        if (!empty($singleRecordUids)) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('tt_address');
            $queryBuilder->setRestrictions(GeneralUtility::makeInstance(FrontendRestrictionContainer::class));
            $queryBuilder
                ->select('*')
                ->from('tt_address')
                ->where(
                    $queryBuilder->expr()->in('uid', $singleRecordUids)
                );

            if (!empty($pids)) {
                $queryBuilder->andWhere($queryBuilder->expr()->in('pid', $pids));
            }

            $result = $queryBuilder->execute();
            while ($address = $result->fetch()) {
                $singleRecords[$address['uid']] = $this->getGroupsForAddress($address);
            }
        }
        return $singleRecords;
    }
1260382
public function getTabs()
    {
        uasort($this->tabs, function($a, $b) {
            return $a['priority'] - $b['priority'];
        });

        return $this->tabs;
    }
53035
public function getAllEntries()
    {
        if ($this->Using === 'APCu') {
            $Data = apcu_cache_info();
            if (empty($Data['cache_list'])) {
                return [];
            }
            $Output = [];
            foreach ($Data['cache_list'] as $Entry) {
                if (empty($Entry['info'])) {
                    continue;
                }
                $Creation = isset($Entry['creation_time']) ? $Entry['creation_time'] : 0;
                $Entry['Data'] = $this->getEntry($Entry['info']);
                $Output[$Entry['info']] = $Entry['ttl'] > 0 ? [
                    'Data' => $Entry['Data'],
                    'Time' => $Creation + $Entry['ttl']
                ] : $Entry['Data'];
            }
            return $Output;
        }
        if ($this->Using === 'Memcached') {
            $Keys = $this->WorkingData->getAllKeys();
            if ($Keys !== false && $this->WorkingData->getDelayed($Keys)) {
                $Data = $this->WorkingData->fetchAll();
            }
            if (!is_array($Data)) {
                return [];
            }
            $Output = [];
            foreach ($Data as $Entry) {
                if (!is_array($Entry) || !isset($Entry['key'], $Entry['value'], $Entry['cas'])) {
                    continue;
                }
                $Output[$Entry['key']] = ['Data' => $this->unserializeEntry($Entry['value'])];
                if ($Entry['cas'] > 2592000) {
                    $Output[$Entry['key']]['Time'] = $Entry['cas'];
                } else {
                    $Output[$Entry['key']] = $Output[$Entry['key']]['Data'];
                }
            }
            return $Output;
        }
        if ($this->Using === 'Redis') {
            $Keys = $this->WorkingData->keys('*') ?: [];
            $Output = [];
            foreach ($Keys as $Key) {
                $Output[$Key] = $this->unserializeEntry($this->WorkingData->get($Key));
            }
            return $Output;
        }
        if ($this->Using === 'PDO') {
            if ($this->clearExpiredPDO()) {
                $this->Modified = true;
            }
            $PDO = $this->WorkingData->prepare(self::getAllQuery);
            if ($PDO !== false && $PDO->execute()) {
                $Data = $PDO->fetchAll();
                $Output = [];
                foreach ($Data as $Entry) {
                    if (!is_array($Entry) || !isset($Entry['Key'], $Entry['Data'], $Entry['Time'])) {
                        continue;
                    }
                    $Output[$Entry['Key']] = $Entry['Time'] > 0 ? [
                        'Data' => $this->unserializeEntry($Entry['Data']),
                        'Time' => $Entry['Time']
                    ] : $this->unserializeEntry($Entry['Data']);
                }
                return $Output;
            }
            return [];
        }
        if ($Arr = ($this->exposeWorkingDataArray() ?: [])) {
            foreach ($Arr as &$Entry) {
                $Entry = $this->unserializeEntry($Entry);
            }
            return $Arr;
        }
        return [];
    }
1255798
public function getFileNames()
    {

        $filesArray = $this->getFiles();
        $filenamesArray = array();

        foreach ($filesArray as $file) {
            $sFileName = $file->getName();
            array_push($filenamesArray, $sFileName);
        }
        sort($filenamesArray);
        return $filenamesArray;
    }
712739
public function getSortedNames()
    {
        $sorted = [];
        $toSort = $this->getDependencies();

        while (count($toSort) > 0) {
            foreach ($toSort as $name => $dependencies) {
                if (!array_diff($dependencies, $sorted)) {
                    $sorted[] = $name;
                    unset($toSort[$name]);
                }
            }
        }

        return $sorted;
    }
226140
public function getSorts()
    {
        $ret = [];

        foreach ($this->fields as $alias => $description) {
            $ret[$alias] = $description['label'];
        }

        return $ret;
    }
753920
public function getSortedCellList()
    {
        $sortKeys = array();
        foreach ($this->getCellList() as $coord) {
            sscanf($coord, '%[A-Z]%d', $column, $row);
            $sortKeys[sprintf('%09d%3s', $row, $column)] = $coord;
        }
        ksort($sortKeys);

        return array_values($sortKeys);
    }
641313
public function all()
    {
        $entries = [];
        while ($keys = $this->redis->scan($it, self::KEY_PREFIX.'*')) {
            foreach ($keys as $key) {
                $entries[substr($key, strlen(self::KEY_PREFIX))] = Collection::make($this->redis->get($key));
            }
        }

        return $entries;
    }
684068
public function getAllSlotsDivided()
    {
        $return = array('radiant' => array(), 'dire' => array());
        foreach ($this->_slots as $slot) {
            $team = 'radiant';
            if ($slot->get('player_slot') > 5) {
                $team = 'dire';
            }
            array_push($return[$team], $slot);
        }
        return $return;
    }
927679
public function getSorting()
    {
        $sortOrder = $this->getRequest()->get('sortOrder', 'asc');
        $sortBy = $this->getRequest()->get('sortBy', 'id');

        return [$sortBy => $sortOrder];
    }
992663
function cacheTracksArray(self) {
  self.tracksInOrder = Object.keys(self.playlist).map(trackById);
  self.tracksInOrder.sort(asc);
  self.tracksInOrder.forEach(function(track, index) {
    track.index = index;
  });

  function asc(a, b) {
    return operatorCompare(a.sortKey, b.sortKey);
  }
  function trackById(id) {
    return self.playlist[id];
  }
}
678517
public function getIndexTitle()
    {
        $respondent = $this->getRespondent();

        return sprintf(
                $this->_('Tracks assigned to %s: %s'),
                $respondent->getPatientNumber(),
                $respondent->getFullName()
                );
    }
1351103
public function toArray()
    {
        $result = parent::toArray();

        $result['hasFile'] = false;

        if ($this->getFileNameFromReport()) {
            /** @var Directory $queueStorage */
            $queueStorage = $this->fileSystemService
                ->getDirectory(QueueDispatcherInterface::FILE_SYSTEM_ID);

            if ($queueStorage->getFile($this->getFileNameFromReport())->exists()) {
                $result['hasFile'] = true;
            }
        }

        return $result;
    }
487745
public static function all()
    {
        foreach (self::getAllPaths() as $path) {
            //Gets all files for each path
            $files = (new Folder($path))->findRecursive('^.+\.ctp$', true);

            foreach ($files as $file) {
                $pages[] = new Entity([
                    'filename' => pathinfo($file, PATHINFO_FILENAME),
                    'path' => rtr($file),
                    'slug' => self::getSlug($file, $path),
                    'title' => self::title(pathinfo($file, PATHINFO_FILENAME)),
                    'modified' => new FrozenTime(filemtime($file)),
                ]);
            }
        }

        return $pages;
    }