Returns all stored segments that haven't been deleted.

@return array
506590
public function getAllSegmentsAndIgnoreVisibility()
    {
        $cacheKey = 'SegmentEditor.getAllSegmentsAndIgnoreVisibility';
        if (!$this->transientCache->contains($cacheKey)) {
            $result = $this->model->getAllSegmentsAndIgnoreVisibility();

            $this->transientCache->save($cacheKey, $result);
        }
        return $this->transientCache->fetch($cacheKey);
    }
205629
public function getFullDataSet () : array
    {
        if ($this->isUsingHandler()) :
            $this->regularize();
            $this->clearCache();

            return $this->_Cache = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);
        else :
            return $this->_Container;
        endif;
    }
375587
public function getTrackDeletionCodes()
    {
        $select = $this->_getDeletionCodeSelect();
        $select->where('(grc_for_tracks = 1 OR grc_for_surveys = ?)', self::APPLY_STOP);

        return $this->_translateAndSort($this->db->fetchPairs($select));
    }
568238
private function getExistingFlashMessages()
    {
        return $this->session->has($this->sessionKey)
            ? $this->session->get($this->sessionKey)
            : [];
    }
153697
public function clear()
    {
        $cleared = [];
        if (false === $this->mf->hasCache()) {
            return $cleared;
        }

        $this->mf->enableCache(false);
        foreach ($this->mf->getAllTypeNames() as $type) {
            $metadata = $this->mf->getMetadataForType($type);
            $this->mf->getCache()->evictMetadataFromCache($metadata);
            $cleared[] = $type;
        }
        $this->mf->enableCache(true);
        $this->mf->clearMemory();
        return $cleared;
    }
857215
public function getDeleteDiff()
    {
        $collectionItems = $this->collection->toArray();

        return array_values(array_diff_key(
            array_combine(array_map('spl_object_id', $this->snapshot), $this->snapshot),
            array_combine(array_map('spl_object_id', $collectionItems), $collectionItems)
        ));
    }
417120
protected function getExtraConditions(array $segments)
    {
        $extra = [];

        $count = count($segments);

        for ($i = 0; $i < $count; $i += 2) {
            $extra[$segments[$i]] = $segments[$i + 1];
        }

        return $extra;
    }
510944
public function getSegmentHashesByIdSite()
    {
        //Get a list of hashes of all segments that exist now
        $sql = "SELECT DISTINCT definition, enable_only_idsite FROM " . Common::prefixTable('segment')
            . " WHERE deleted = 0";
        $rows = Db::fetchAll($sql);
        $segmentHashes = array();
        foreach ($rows as $row) {
            $idSite = (int)$row['enable_only_idsite'];
            if (! isset($segmentHashes[$idSite])) {
                $segmentHashes[$idSite] = array();
            }
            $segmentHashes[$idSite][] = Segment::getSegmentHash($row['definition']);
        }

        return $segmentHashes;
    }
73781
private function getUnsortedProductData()
    {
        $productCollection = $this->getProductCollection()->setPageSize($this->size);

        if (!in_array($this->search, [null, ''])) {
            $productCollection->setSearchQuery($this->search);
        }

        return ['products' => $productCollection->getItems(), 'size' => $productCollection->getSize()];
    }
754390
public function getDeleted()
    {
        $set = new ArrayList();
        foreach ($this->deleted as $arrItem) {
            $set->push(ArrayData::create($arrItem));
        }
        return $set;
    }
1353204
public function getParts()
    {
        return array(
            'scheme'   => $this->scheme,
            'user'     => $this->username,
            'pass'     => $this->password,
            'host'     => $this->host,
            'port'     => $this->port,
            'path'     => $this->path,
            'query'    => $this->query,
            'fragment' => $this->fragment,
        );
    }
147916
public static function getAllPersistedAttributes() {
    $calledClass = get_called_class();

    if (array_key_exists($calledClass, self::$allPersisted)) {
      return self::$allPersisted[$calledClass];
    } else {
      $persisted = [];
      if(property_exists($calledClass, 'persisted')) {
        $persisted  = $calledClass::$persisted;
      }
      $parent = get_parent_class($calledClass);
      if (method_exists($parent, 'getAllPersistedAttributes')) {
        $persisted = array_merge($persisted, $parent::getAllPersistedAttributes());
      }
    }
    self::$allPersisted[$calledClass] = $persisted;
    return self::$allPersisted[$calledClass];
  }
695369
public function all()
    {
        $res = [];
        $len = count($this->fragments);

        for ($index=0; $index < $len; $index++) {
            $res[] = $this->get($index);
        }

        return $res;
    }
383120
public function getAllDeathPlaces(): array
    {
        foreach (Gedcom::DEATH_EVENTS as $event) {
            $places = $this->getAllEventPlaces([$event]);
            if (!empty($places)) {
                return $places;
            }
        }

        return [];
    }
735598
public function getSegments() {

            if(!isset($this->segments))
                $this->segments = explode('/', $this->path);

            return $this->segments;

        }
968368
public function getAll(){
        $rest = $this->getService( self::API_STORAGE_PARTITION);
        $rest->GET();

        return $rest->getResultAsArray( models\Storage\DiskPartition::class);
    }
1324630
private function getPartsFromSegment(string $segment): array
    {
        $parts = explode(DIRECTORY_SEPARATOR, $segment);

        return array_filter($parts, function ($part) {
            return $this->isNotEmpty($part);
        });
    }