Loads data from the cache (DB).

@param string $entryIdentifier An identifier which describes the cache entry to load

@return mixed The cache entry's content as a string or FALSE if the cache entry could not be loaded
329191
public function get($entryIdentifier)
    {
        if (!$this->has($entryIdentifier)) {
            return false;
        }
        $result = parent::get($entryIdentifier);
        if (!\is_string($result)) {
            return false;
        }

        return \unserialize($result);
    }
1168325
public function remove(string $entryIdentifier): bool
    {
        if (!isset($this->entries[$entryIdentifier])) {
            return false;
        }
        unset($this->entries[$entryIdentifier]);
        foreach (array_keys($this->tagsAndEntries) as $tag) {
            if (isset($this->tagsAndEntries[$tag][$entryIdentifier])) {
                unset($this->tagsAndEntries[$tag][$entryIdentifier]);
            }
        }
        return true;
    }
1158630
public function loadGroupDataByIdentifier($identifier)
    {
        $q = $this->createGroupLoadQuery();
        $q->where(
            $q->expr->eq(
                $this->dbHandler->quoteColumn('name'),
                $q->bindValue($identifier, null, \PDO::PARAM_STR)
            )
        );
        $stmt = $q->prepare();
        $stmt->execute();

        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }
952176
public function addIdentifier(string $identifier)
    {
        $count = $this->queueRepository->countOpenByIdentifier($identifier);
        if ($count > 0) {
            return;
        }

        $this->logger->debug('SFC Queue add', [$identifier]);

        $data = [
            'cache_url' => $identifier,
            'page_uid' => 0,
            'invalid_date' => \time(),
            'call_result' => '',
        ];

        $this->queueRepository->insert($data);
    }
685193
public static function getCached($identifier, $accessor) {
    if (!self::isCached($identifier, $accessor)) {
      return false;
    }

    return self::$cache[$identifier][$accessor];
  }
901676
public function get($identifier = null)
    {
        $result = null;

        if (null === $identifier) {
            $result = self::$lookup;
        } elseif ('doozr.registry' === $identifier) {
            $result = $this;
        } else {
            if (true === isset(self::$lookup[$identifier])) {
                $result = self::$references[self::$lookup[$identifier]];
            }
        }

        return $result;
    }
1232565
public function remove(string $entryIdentifier, string $fileName)
    {
        foreach ($this->getImplementationObjects() as $implementation) {
            /* @var $implementation AbstractGenerator */
            $implementation->remove($entryIdentifier, $fileName);
        }
    }
200516
public function has(string $entryIdentifier): bool
    {
        if (!$this->isValidEntryIdentifier($entryIdentifier)) {
            throw new \InvalidArgumentException('"' . $entryIdentifier . '" is not a valid cache entry identifier.', 1233058486);
        }

        return $this->backend->has($entryIdentifier);
    }
644351
protected function _locate(KObjectIdentifier $identifier, $fallback = true)
    {
        $class = $this->__registry->getClass($identifier);

        //If the class is FALSE we have tried to locate it already, do not locate it again.
        if($class !== false)
        {
            //Set loader basepath if we are locating inside an application
            if($this->isRegistered('object.bootstrapper'))
            {
                if($path = $this->getObject('object.bootstrapper')->getApplicationPath($identifier->domain)) {
                    $this->getClassLoader()->setBasePath($path);
                }
            }

            if(empty($class))
            {
                $class = $this->_locators[$identifier->getType()]->locate($identifier, $fallback);

                //If we are falling back set the class in the registry
                if($fallback)
                {
                    if(!$this->__registry->get($identifier) instanceof KObjectInterface) {
                        $this->__registry->setClass($identifier, $class);
                    }
                }
            }
        }

        return $class;
    }
876824
public function get(string $entryIdentifier)
    {
        $value = $this->memcache->get($this->identifierPrefix . $entryIdentifier);
        if (substr($value, 0, 13) === 'Flow*chunked:') {
            list(, $chunkCount) = explode(':', $value);
            $value = '';
            for ($chunkNumber = 1; $chunkNumber < $chunkCount; $chunkNumber++) {
                $value .= $this->memcache->get($this->identifierPrefix . $entryIdentifier . '_chunk_' . $chunkNumber);
            }
        }
        return $value;
    }
154421
private function loadFromSource($ident)
    {
        $obj = $this->factory->create($this->objType);
        if ($this->objKey) {
            $obj->loadFrom($this->objKey, $ident);
        } else {
            $obj->load($ident);
        }

        return $obj;
    }
906177
public function isLoaded($identifier)
    {
        $user = $this->getObject('user');

        // Find the user id
        if (!is_numeric($identifier))
        {
            if(!$identifier = JUserHelper::getUserId($identifier)) {
                $identifier = 0;
            }
        }

        if($identifier == 0 || $user->getId() != $identifier) {
            $result = isset($this->_users[$identifier]);
        } else {
            $result = true;
        }

        return $result;
    }
909781
public function getFromPageIdentifier( PageIdentifier $pageIdentifier ) {
		if ( !$pageIdentifier->identifiesPage() ) {
			throw new InvalidArgumentException( '$pageIdentifier does not identify a page' );
		}

		if ( !is_null( $pageIdentifier->getId() ) ) {
			return $this->getFromPageId( $pageIdentifier->getId() );
		} else {
			return $this->getFromTitle( $pageIdentifier->getTitle() );
		}
	}
668132
public function get($entryIdentifier)
    {
        if (!$this->has($entryIdentifier)) {
            return false;
        }

        return self::RELATIVE_STORAGE_FOLDER . $this->getFileName($entryIdentifier);
    }
796058
public function loadGroupDataByIdentifier($identifier)
    {
        try {
            return $this->innerGateway->loadGroupDataByIdentifier($identifier);
        } catch (DBALException $e) {
            throw new RuntimeException('Database error', 0, $e);
        } catch (PDOException $e) {
            throw new RuntimeException('Database error', 0, $e);
        }
    }
331730
final public function getIdentifier($identifier = null)
	{
		if(isset($identifier)) {
		    $result = $this->__service_container->getIdentifier($identifier);
		} else {
		    $result = $this->__service_identifier; 
		}
	    
	    return $result;
	}
1122108
public function getChannel($channelIdentifier)
    {
        if ($this->apiVersionIsGreaterThanV3() && !is_numeric($channelIdentifier)) {
            throw new InvalidIdentifierException('channel');
        }

        return $this->get(sprintf('channels/%s', $channelIdentifier));
    }