Returns previously stored request token secret.

See {@link self::set_request_token_secret()} for more details on the
$identifiers argument.

@param array $identifiers Identification of the call
@return string|bool False on error, string secret otherwise.
763856
public function get_request_token_secret(array $identifiers) {

        if (empty($identifiers) || empty($identifiers['caller'])) {
            throw new coding_exception('Invalid call identification');
        }

        $cache = cache::make_from_params(cache_store::MODE_SESSION, 'core', 'flickrclient', $identifiers);

        return $cache->get('request_token_secret');
    }
946708
public function getContentTypesByIdentifier($identifier)
    {
        if (strstr($identifier, ',')) {
            $contentTypeArray = explode(',', $identifier);
        } else {
            $contentTypeArray[] = $identifier;
        }

        $contentTypesCollection = array();
        foreach ($contentTypeArray as $contentTypeIdentifier) {
            if (!empty($contentTypeIdentifier)) {
                $contentTypesCollection[] = $this->contentTypeService->loadContentTypeByIdentifier($contentTypeIdentifier);
            }
        }

        return $contentTypesCollection;
    }
732470
protected function convertIdentifierToObjects(array $identifiers)
    {
        $idName = DomainUtil::getIdentifierName($this->om, $this->getClass());
        $objects = [];
        $missingIds = [];
        $searchIds = DomainUtil::extractIdentifierInObjectList($identifiers, $objects);

        if (\count($searchIds) > 0) {
            $previousFilters = $this->disableFilters();
            $searchObjects = $this->getRepository()->findBy([$idName => $searchIds]);
            $this->enableFilters($previousFilters);
            $objects = array_merge($objects, $searchObjects);

            if (\count($searchIds) !== \count($searchObjects)) {
                $missingIds = $searchIds;

                foreach ($objects as $object) {
                    $pos = array_search(DomainUtil::getIdentifier($this->om, $object), $missingIds, true);

                    if (false !== $pos) {
                        array_splice($missingIds, $pos, 1);
                    }
                }
            }
        }

        return [$objects, $missingIds];
    }
649904
protected function quoteIdentifier($identifier)
    {
        if (!is_array($identifier)) {
            return $this->connection->quoteIdentifier($identifier);
        }

        foreach ($identifier as &$value) {
            $value = $this->connection->quoteIdentifier($value);
            unset($value);
        }

        return $identifier;
    }
1170521
public function retrieveByToken($identifier, $token)
	{
		$user = $this->conn->table($this->table)
			->where('id', $identifier)
			->where('remember_token', $token)
			->first();

		return $this->getGenericUser($user);
	}
15399
private function generateIdentifiersUrl(array $identifiers, string $resourceClass): array
    {
        if (0 === \count($identifiers)) {
            throw new InvalidArgumentException(sprintf(
                'No identifiers defined for resource of type "%s"',
                $resourceClass
            ));
        }

        if (1 === \count($identifiers)) {
            return [rawurlencode((string) reset($identifiers))];
        }

        foreach ($identifiers as $name => $value) {
            $identifiers[$name] = sprintf('%s=%s', $name, $value);
        }

        return array_values($identifiers);
    }
952483
public function loadContentTypeGroupsByIdentifiers(array $identifiers)
    {
        $contentTypeGroups = array_map(
            function ($identifier) {
                try {
                    return $this->contentTypeService->loadContentTypeGroupByIdentifier($identifier);
                } catch (NotFoundException $notFoundException) {
                    return $this->createContentTypeGroupByIdentifier($identifier);
                }
            },
            $identifiers
        );

        return $contentTypeGroups;
    }
596814
public static function stringify_identifier($identifier)
	{
		// Identifier may not be empty, but can be false or 0
		if ($identifier === '' || $identifier === null)
		{
			throw new \FuelException('The identifier cannot be empty, must contain a value of any kind other than null or an empty string.');
		}

		// In case of string or int just return it as a string
		if (is_string($identifier) || is_int($identifier))
		{
			// cleanup to only allow alphanum chars, dashes, dots & underscores
			if (preg_match('/^([a-z0-9_\.\-]*)$/iuD', $identifier) === 0)
			{
				throw new \FuelException('Cache identifier can only contain alphanumeric characters, underscores, dashes & dots.');
			}

			return (string) $identifier;
		}
		// In case of array, bool or object return the md5 of the $identifier's serialization
		else
		{
			return '_hashes.'.md5(serialize($identifier));
		}
	}
962793
protected static function _parseIdentifier($identifier)
    {
        $parts = array();
        $hash  = $identifier;

        // Validate the variable format
        if (strpos($identifier, '.') !== false) {
            // Split the variable name into it's parts
            $parts = explode('.', $identifier);

            // Validate the hash name
            $hash   = array_shift($parts);
        }

        $hash = strtoupper($hash);

        return array($hash, $parts);
    }
1183016
public function set_identifiers(array $identifiers = array()) {
        if ($this->identifiers !== null) {
            throw new coding_exception("You can only set identifiers on initial definition creation." .
                " Define a new cache to set different identifiers.");
        }
        if (!empty($identifiers) && !empty($this->invalidationevents)) {
            throw new coding_exception("You cannot use event invalidation and identifiers at the same time.");
        }

        foreach ($this->requireidentifiers as $identifier) {
            if (!isset($identifiers[$identifier])) {
                throw new coding_exception('Identifier required for cache has not been provided: '.$identifier);
            }
        }

        $this->identifiers = array();

        foreach ($identifiers as $name => $value) {
            $this->identifiers[$name] = (string)$value;
        }
        // Reset the key prefix's they need updating now.
        $this->keyprefixsingle = null;
        $this->keyprefixmulti = null;

        return true;
    }
1096740
public function getContentByIds(array $identifiers)
    {
        $sql = sprintf(
            'SELECT * FROM %s WHERE entityId IN (`%s`);',
            $this->mysql->quote($this->section),
            implode('`,`', $identifiers)
        );
        $result = $this->mysql->query($sql);

        if (false === $result) {

            $this->throwException(
                'Error occurred while querying the registry: ',
                $this->mysql->errorInfo()
            );
        }

        $content = $result->fetchAll(\PDO::FETCH_ASSOC);
        $this->registry[$this->section] = array_merge($this->registry[$this->section], $content);

        return $content;
    }
812293
public function escapeIdentifiers(array $identifiers): array
	{
		foreach($identifiers as $key => $identifier)
		{
			$identifiers[$key] = $this->escapeIdentifier($identifier);
		}

		return $identifiers;
	}
880675
private function MatchIdentifer( $identifer )
	{
		if ( ! is_array( $identifer ) )
		{
			$identifer = array( $identifer );
		}

		$i = 0;
		for ( $sp = 0; $sp < count( $identifer ); $sp++ )
		{
			$c;
			while ( true )
			{
				if ( ( $c = $this->Peek( $i ) ) && ord( $c ) != 0 && preg_match( "/\s/", $c ) )
				{
					while ( ( $c = $this->Peek( $i ) ) && ord( $c ) != 0 && preg_match( "/\s/", $c ) )
						$i++;
					continue;
				}
				if ( $this->Peek( $i ) == '(' && $this->Peek( $i + 1 ) == ':' )
				{
					$n = 1;
					$i += 2;
					while ( true )
					{
						$c = $this->Peek( $i );
						if ( $c ==  '\0' )
							break;
						else if ( $c == '(' && $this->Peek( $i + 1 ) == ':' )
						{
							$i += 2;
							$n++;
						}
						else if ( $c == ':' && $this->Peek( $i + 1 ) == ')' )
						{
							$i += 2;
							if ( --$n == 0 )
								break;
						}
						else
							$i++;
					}

					if ( $n )
					{
						throw XPath2Exception::withErrorCodeAndParam( "XPST0003", Resources::XPST0003, "Comment not closed" );
					}

					continue;
				}
				break;
			}
			$s = $identifer[ $sp ];
			$this->m_bookmark[ $sp ] = $this->getPosition() + $i;
			if ( strlen( $s ) > 0 )
			{
				for ( $k = 0; $k < strlen( $s ); $k++, $i++ )
					if ( ( $c = $this->Peek( $i ) ) && ord( $c ) == 0 || $c != $s[ $k ] )
						return false;
				if ( preg_match( "/[\p{L}_]/u", $s[0] ) && // NCName Start char
					 preg_match( "/[\p{L}\p{N}_\-.]/u", $this->Peek( $i ) ) ) // NCName char
					return false;
			}
		}
		while ( $i-- > 0 )
			$this->Read();
		return true;
	}
1298072
public function retrieveByToken( $identifier, $token )
	{
		$acct = $this->conn->table( $this->table )->where( 'id', $identifier )->where( 'remember_token', $token )->first();

		return $this->getGenericAccount( $acct );
	}
1152200
public function retrieveByToken($identifier, $token)
    {
        $model = $this->createModel();

        return $model->where($model->getKeyName(), $identifier)->first();
    }
1354056
public function retrieveByToken($identifier, $token)
    {
        $userModel = $this->createUserModel();

        return $userModel->newQuery()
            ->where($userModel->getKeyName(), $identifier)
            ->where($userModel->getRememberTokenName(), $token)
            ->first();
    }
983176
protected function _stringToSemKey($identifier)
    {
        $md5 = md5($identifier);
        $key = 0;
        for ($i = 0; $i < 32; $i++) {
            $key += ord($md5{$i}) * $i;
        }
        return $key;
    }