Checks if the specified cache has been registered.

@param string $identifier The identifier of the cache
@return boolean true if a cache with the given identifier exists, otherwise false
@api
501721
public function hasCache(string $identifier): bool
    {
        return isset($this->caches[$identifier]) || isset($this->cacheConfigurations[$identifier]);
    }
1077573
public function offsetExists($identifier)
    {
        $keys   = $this->_parseIdentifier($identifier);
        $last   = count($keys)-1;
        $data   = &$this->_data;
        $result = false;

        foreach($keys as $index => $key)
        {
            if (!array_key_exists($key, $data)) {
                break;
            }

            if ($index < $last) {
                $data =& $data[$key];
            }
            else $result = true;
        }

        return $result;
    }
916743
public function getEntityByIdentifier($identifier)
    {
        $found_entities = $this->filter(
            function (EntityInterface $entity) use ($identifier) {
                return $entity->getIdentifier() === $identifier;
            }
        );

        return $found_entities->getFirst();
    }
933224
public function checkRegistered($provider_name, $identifier) {
        $user = $this->user_repository->findbyAuth($provider_name, $identifier);
        return ($user !== null);
    }
356928
public function find($identifier)
    {
        $identifier = (string) $identifier;

        //Resolve the real identifier in case an alias was passed
        while(array_key_exists($identifier, $this->_aliases)) {
            $identifier = $this->_aliases[$identifier];
        }

        //Find the identifier
        if($this->offsetExists($identifier))
        {
            $result = $this->offsetGet($identifier);

            if($result instanceof KObjectInterface) {
                $result = $result->getIdentifier();
            }
        }
        else  $result = null;

        return $result;
    }
645062
public function isRegistered($identifier)
    {
        $this->verifySectionName($identifier);

        return array_key_exists($identifier, $this->registry[$this->section]);
    }
464600
public function isMultiton($identifier)
    {
        $result = false;
        $class  = $this->getClass($identifier);

        if($class) {
            $result = array_key_exists(__NAMESPACE__.'\ObjectMultiton', class_implements($class));
        }

        return $result;

    }
485824
public function setIdentifier($identifier) {

		if(false === is_array($identifier)) {
			$identifier = [$identifier];
		}

		$this -> identifier = $identifier;
	}
14179
public function countOpenByIdentifier($identifier): int
    {
        $queryBuilder = $this->createQuery();
        $where = $queryBuilder->expr()->andX(
            $queryBuilder->expr()->eq('cache_url', $queryBuilder->createNamedParameter($identifier)),
            $queryBuilder->expr()->eq('call_date', $queryBuilder->createNamedParameter(0))
        );

        return (int)$queryBuilder->select('uid')
            ->from($this->getTableName())
            ->where($where)
            ->execute()
            ->rowCount();
    }
817728
public function idExists($identifer = null)
    {
        if (is_null($identifer)) {
            $identifer = $this->getMyKey();
        }
        $ignorestate = $this->ignore404();
        $this->ignore404(true);
        $cands       = $this->getFlexiData(null,
            [
                'detail' => 'custom:'.$this->getKeyColumn(),
                $this->getKeyColumn() => $identifer
        ]);
        $this->ignore404($ignorestate);
        return ($this->lastResponseCode == 200) && !empty($cands);
    }
1037986
public function hasIdentifier($identifier)
    {
        if(!$identifier instanceof ObjectIdentifierInterface) {
            $identifier = $this->getIdentifier($identifier);
        }

        return in_array((string) $identifier, $this->__identifier_list);
    }
1264844
public function remove($identifier)
    {
        if (!$this->has($identifier)) {
            return null;
        }

        $removedValue = $this->container[$identifier];

        unset($this->container[$identifier]);

        return $removedValue;
    }
976343
public function getDescendant($identifier) {
        $iterator = $this->getIterator();
        $key = $this->has($identifier);
        if ($key < $iterator->count()) {
            $iterator->seek($key + 1);
            return $iterator->current();
        }
        return false;

    }
1323233
public static function driverClass($identifier) {
		if (!isset(self::$registry[$identifier])) {
			return null;
		}

		return self::$registry[$identifier];
	}
448309
public function isRegistered($identifier)
    {
        if(strpos($identifier, '.') !== false )
        {
            $identifier = $this->getIdentifier($identifier);
            $class      = $this->getObject('manager')->getClass($identifier);

            if(!$class || !array_key_exists('KTemplateEngineInterface', class_implements($class)))
            {
                throw new UnexpectedValueException(
                    'Engine: '.$identifier.' does not implement KTemplateEngineInterface'
                );
            }

            $types = call_user_func(array($class, 'getFileTypes'));/*$class::getFileTypes();*/
        }
        else $types = (array) $identifier;

        $result = in_array($types, $this->getFileTypes());
        return $result;
    }
501550
private function get($identifier)
    {
        $fileSystem= $this->getConfigFileSystem();

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

        return false;
    }
1340970
protected function match($row, $identifier)
    {
        foreach ($identifier as $key => $value) {
            if ($row[$key] != $value) {
                return false;
            }
        }

        return true;
    }