Creates a key for cached class methods
@param  array $identifier  class|method|args
@return string
508872
private function _key($identifier) {
    	extract($identifier);
    	$arg_string = "";
    	return md5(serialize($class . $method . implode('~', $args)));
    }
512803
public function get_method($identifier)
    {
        extract($identifier);

        $directory = $this->_prep_path($class, $method);

        // create a unique field name
        $filename = $this->_hash($args);

        $result = $this->_read($filename, $directory);

        return is_null($result) ?
            array('status' => false, 'data' => null) :
            array('status' => true, 'data' => $result);
    }
961722
public function loadSectionDataByIdentifier($identifier)
    {
        try {
            return $this->innerGateway->loadSectionDataByIdentifier($identifier);
        } catch (DBALException $e) {
            throw new RuntimeException('Database error', 0, $e);
        } catch (PDOException $e) {
            throw new RuntimeException('Database error', 0, $e);
        }
    }
43332
protected function findTagsByIdentifier(string $identifier): array
    {
        $tags = $this->memcache->get($this->identifierPrefix . 'ident_' . $identifier);
        return ($tags === false ? [] : (array)$tags);
    }
530770
public function remove($identifier)
    {
        $keys = $this->_parseIdentifier($identifier);

        foreach($keys as $key)
        {
            if(array_key_exists($key, $this->_data))
            {
                unset($this->_data[$key]);
                break;
            };
        }

        return $this;
    }
151067
public function getIdentifiedElement($identifier, $elementClasses = array()){
        $returnValue = null;

        if(!is_array($elementClasses)){
            throw new InvalidArgumentException('elementClasses must be an array');
        }

        $relatedItem = $this->getRelatedItem();

        if(!is_null($relatedItem)){
            $identifiedElementsCollection = $relatedItem->getIdentifiedElements();

            if(empty($elementClasses)){
                $returnValue = $identifiedElementsCollection->getUnique($identifier);
            }else{
                foreach($elementClasses as $elementClass){
                    $returnValue = $identifiedElementsCollection->getUnique($identifier, $elementClass);
                    if(!is_null($returnValue)){
                        break;
                    }
                }
            }
        }

        return $returnValue;
    }
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;
    }
898986
public function retrieveById( $identifier )
	{
		$acct = $this->conn->table( $this->table )->find( $identifier );

		return $this->getGenericAccount( $acct );
	}
723257
public function getParameterBag($identifier)
    {
        if (isset($this->parameterBags[$identifier])) {
            return $this->parameterBags[$identifier];
        }

        return null;
    }
45403
static public function getIndexById($identifier) {
        
        $indexClass = new core_kernel_classes_Class(OntologyIndex::RDF_TYPE);
        $resources = $indexClass->searchInstances(array(
            OntologyIndex::PROPERTY_INDEX_IDENTIFIER  => $identifier
            ),array('like' => false)
        );
        if (count($resources) > 1) {
            throw new \common_exception_InconsistentData("Several index exist with the identifier ".$identifier);
        }
        return count($resources) > 0
            ? new OntologyIndex(array_shift($resources))
            : null;
    }
126917
public static function get($identifier, $use_expiration = true)
	{
		$cache = static::forge($identifier);
		return $cache->get($use_expiration);
	}
1144993
public function tryGetByIdentifier(Identifier $identifier)
    {
        $mapId     = $identifier->getSerialized();
        $className = $identifier->class->getName();

        if (!isset($this->identityMap[$className][$mapId])) {
            return false;
        }

        return $this->identityMap[$className][$mapId];
    }
1168228
public function getClass($identifier)
    {
        $result     = null;
        $identifier = (string) $identifier;

        if(isset($this->_classes[$identifier])) {
            $result = $this->_classes[$identifier];
        }

        return $result;
    }
114295
private function generateIdentifierName($identifier)
    {
        // Always generate name for unquoted identifiers to ensure consistency.
        $identifier = new Identifier($identifier);

        return strtoupper(dechex(crc32($identifier->getName())));
    }
670285
public function loadIdentifier($identifier)
    {
        $result = false;

        $identifier = AnService::getIdentifier($identifier);

        //Get the path
        $path = $identifier->filepath;

        if ($path !== false) {
            $result = self::loadFile($path);
        }

        return $result;
    }
393608
public function retrieveById($identifier)
    {
        $model = $this->createModel();
        $query = $model->newQuery();
        $identifierName = $model->getAuthIdentifierName();

        if (! $model instanceof UserContract) {
            $query->whereHas('user', function ($query) use ($identifier, $identifierName) {
                $query->where($identifierName, $identifier);
            });
        } else {
            $query->where($identifierName, $identifier);
        }

        return $query->first();
    }
1205393
public static function escapeIdentifier($identifier = null) {
		$sqlAdapter = static::getSQLAdapter();
		return $sqlAdapter->escapeIdentifier($identifier ? $identifier : static::$table);
	}