Fetches data from the cache.

@param string $identifier The file to fetch data from
@param bool $object return the object and not the clean data
@return mixed The fetched data or false on failure
196580
protected function fetchData( $identifier, $object = false )
    {
        $data = $this->backend->fetch( $identifier );
        if ( is_object( $data ) && $object === false )
        {
            return $data->data;
        }
        if ( is_object( $data ) && $object !== false )
        {
            return $data;
        }
        else
        {
            return false;
        }
    }
552687
public function parseIdentifier(ObjectIdentifier $identifier)
    {
        $package = ucfirst($identifier->package);
        $path    = StringInflector::implode($identifier->path);
        $file    = ucfirst($identifier->name);
        $class   = $path.$file;

        $info = array(
            'class'      => $class,
            'package'    => $package,
            'path'       => $path,
            'file'       => $file,
        );

        return $info;
    }
303824
public function getWebhook($identifier) {
        $response = $this->blocktrailClient->get("webhook/".$identifier);
        return self::jsonDecode($response->body(), true);
    }
1074011
public function loadObjectStateDataByIdentifier($identifier, $groupId)
    {
        $query = $this->createObjectStateFindQuery();
        $query->where(
            $query->expr->lAnd(
                $query->expr->eq(
                    $this->dbHandler->quoteColumn('identifier', 'ezcobj_state'),
                    $query->bindValue($identifier, null, \PDO::PARAM_STR)
                ),
                $query->expr->eq(
                    $this->dbHandler->quoteColumn('group_id', 'ezcobj_state'),
                    $query->bindValue($groupId, null, \PDO::PARAM_INT)
                )
            )
        );

        $statement = $query->prepare();
        $statement->execute();

        return $statement->fetchAll(\PDO::FETCH_ASSOC);
    }
501550
private function get($identifier)
    {
        $fileSystem= $this->getConfigFileSystem();

        if($fileSystem->has($identifier)){
            return json_decode($fileSystem->read($identifier),true);
        }

        return false;
    }
191824
public function fetch($identifier, $lazyload = false)
    {
        $identifiers = array_merge((array) $identifier, $this->_fetch);

        //Only fetch identifiers that haven't been loaded yet.
        foreach($identifiers as $key => $value)
        {
            if($this->isLoaded($value)) {
                unset($identifiers[$key]);
            }
        }

        if(!empty($identifiers))
        {
            if (!$lazyload)
            {
                if (!is_numeric($identifiers[0])) {
                    $users = $this->getModel()->email($identifiers)->fetch();
                } else {
                    $users = $this->getModel()->id($identifiers)->fetch();
                }

                if(count($users))
                {
                    foreach($users as $user) {
                        $this->setUser($user);
                    }

                    return true;
                }
            }
            else $this->_fetch = $identifiers;
        }

        return false;
    }
1237189
static function fetchPartByIdentifier( $identifier )
    {
        $parts = eZNavigationPart::fetchList();

        if ( isset( $parts[$identifier] ) )
            return $parts[$identifier];

        // Return the first part which is the default
        if ( isset( $parts[0] ) )
            return $parts[0];

        return false;
    }
276605
public function registerObject($object, $identifier)
    {
        $this->objectMap[$object] = $identifier;
        $this->identifierMap[$identifier] = $object;
    }
806841
public function get($identifier)
    {
        $identifier = (string) $identifier;

        if($this->offsetExists($identifier)) {
            $result = $this->offsetGet($identifier);
        } else {
            $result = null;
        }

        return $result;
    }
126917
public static function get($identifier, $use_expiration = true)
	{
		$cache = static::forge($identifier);
		return $cache->get($use_expiration);
	}
243569
public function get($identifier)
	{
		if (!isset($this->configs[$identifier])) {
			$files = $this->path->find('config.' . $identifier, false);
			
			$config = array();
			foreach ($files as $file) {
				$fileContent = include($file);
				$fileContent = $fileContent ? $fileContent : array();
				$config = array_merge($config, $fileContent);
			}
			
			$this->config[$identifier] = $config;
		}

		return $this->config[$identifier];
	}
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;
    }
227447
public function retrieveByToken($identifier, $token) {
		$m = $this->modelName;
		return $m::findForAuthToken($identifier, $token);
	}
239742
public static function fetchByIdentifier( $identifier )
    {
        $db = eZDB::instance();
        $identifier = $db->escapeString( $identifier );
        $stateGroups = self::fetchByConditions( array( "ezcobj_state_group.identifier='$identifier'" ), 1, 0 );
        $stateGroup = count( $stateGroups ) > 0 ? $stateGroups[0] : false;
        return $stateGroup;
    }
394970
public function getByIdentifier($identifier)
    {
        if (isset($this->nodesByIdentifier[$identifier])) {
            return $this->nodesByIdentifier[$identifier];
        }

        return false;
    }
1071676
public function getAncestor($identifier) {
        $key = $this->has($identifier);
        if ($key > 0) {
            $iterator = $this->getIterator();
            $iterator->seek($key - 1);
            return $iterator->current();
        }
        return false;

    }
618805
public function getDeliveryExecution($identifier)
    {
        $query = $this->getQueryBuilder()
            ->select("*")
            ->from(self::TABLE_NAME)
            ->where(self::COLUMN_ID . " = :id")
            ->setParameter("id", $identifier)
        ;

        $result = $query->execute()->fetch();

        if (!$result) {
            $result = [];
        }

        return $this->parseQueryResult($result);
    }