Retrieve a user by their unique identifier.

@param mixed $identifier
@return \Illuminate\Contracts\Auth\Authenticatable|null
967282
public function retrieveById($identifier) {
        if (!$this->isValidIdentifierValue($identifier)) {
            return null;
        }
        /** @var RecordInterface $user */
        $user = $this->createEmptyUserRecord()->fromPrimaryKey($identifier, [], $this->getRelationsToFetch());

        return $this->validateUser($user, null);
    }
1050464
public function findAuthenticatedUser()
    {

        $token = $this->getSecurityTokenStorage()->getToken();

        if (null !== $token) {

            $user = $token->getUser();

            if (is_object($user) && $user instanceof UserInterface) {
                return $user;
            }

        }
        return null;
    }
618153
public function fetch($identifier)
    {
        $table = JUser::getTable();

        if ($table->load($identifier))
        {
            $user = JUser::getInstance(0);
            $user->setProperties($table->getProperties());

            $params = new JRegistry;
            $params->loadString($table->params);

            $user->setParameters($params);

            $data = array(
                'id'         => $user->id,
                'email'      => $user->email,
                'name'       => $user->name,
                'username'   => $user->username,
                'password'   => $user->password,
                'salt'       => '',
                'groups'     => JAccess::getGroupsByUser($user->id),
                'roles'      => JAccess::getAuthorisedViewLevels($user->id),
                'authentic'  => !$user->guest,
                'enabled'    => !$user->block,
                'expired'    => (bool) $user->activation,
                'attributes' => $user->getParameters()->toArray()
            );

            $user = $this->create($data);
        }
        else $user = null;

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

		return $this->getGenericAccount( $acct );
	}
794186
public function get($identifier, $default = null)
    {
       $result = $this->offsetGet($identifier);

        // If the value is null return the default
        if(is_null($result)) {
            $result = $default;
        }

        return $result;
    }
1252745
public function getSingle($identifier, $default = null)
    {
        $get = $this->get($identifier, $default);
        if (is_array($get)) {
            return array_values($this->identifiers[$identifier])[0];
        }

        return $get;
    }
1219023
public function findStandardIdentityByIdentifier(string $identifier): Entity\StandardIdentity
    {
        $identity = new Entity\StandardIdentity;
        $identity->setIdentifier($identifier);

        $this->repository->load($identity);

        if ($identity->getId() === null) {
            $this->logger->notice('identity not found', [
                'input' => [
                    'identifier' => $identifier,
                ],
            ]);

            throw new IdentityNotFound;
        }

        return $identity;
    }
857348
public function retrieveByID($identifier)
    {
        $user = $this->conn->{$this->table}->findOne(array('_id' => new \MongoId($identifier)));

        if ( ! is_null($user))
        {
            return new MongolUser((array) $user);
        }
    }
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];
    }
629435
protected function _findIdentity($identifier)
    {
        $fields = $this->getConfig('fields.' . self::CREDENTIAL_USERNAME);
        $conditions = [];
        foreach ((array)$fields as $field) {
            $conditions[$field] = $identifier;
        }

        return $this->getResolver()->find($conditions, ResolverInterface::TYPE_OR);
    }
486125
public function findOneByIdentifier($identifier) {
		$statement = $this->connection->prepare('SELECT * FROM objects WHERE __identifier__ = :identifier LIMIT 1');
		$statement->bindValue(':identifier', $identifier);

		return $statement->execute()->fetchArray(SQLITE3_ASSOC);
	}
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);
    }
486569
public function getAssignmentForIdentifier($identifier)
    {
        $assignment = $this->assignments->find(array('actortype' => (string) $identifier));
        $access = ($assignment) ? $assignment->access : self::ACCESS_NEVER;

        return (int) $access;
    }
862346
public function retrieve($identifier)
    {
        try {
            return FileSystemFile::retrieveFile($identifier);
        } catch (RuntimeException $e) {
            $msg = "An error occured while retrieving a QTI FileSystemFile object.";
            throw new FileManagerException($msg, 0, $e);
        }
    }
1233455
public function findByIdentifier($identifier)
    {
        if (!isset($this->plugins[$identifier])) {
            $identifier = $this->normalizeIdentifier($identifier);
        }

        if (!isset($this->plugins[$identifier])) {
            return null;
        }

        return $this->plugins[$identifier];
    }
230119
public function getByIdentifier($identifier)
    {
        switch (APP_NATIVE_LOGIN_USING) {

            case 'EMAIL':
                $user = $this->getByEmail($identifier);
                break;

            case 'USERNAME':
                $user = $this->getByUsername($identifier);
                break;

            default:
                Factory::helper('email');
                if (valid_email($identifier)) {
                    $user = $this->getByEmail($identifier);
                } else {
                    $user = $this->getByUsername($identifier);
                }
                break;
        }

        return $user;
    }
1045971
public function getParameter($identifier)
    {
        return isset($this->parameters[$identifier]) ? $this->parameters[$identifier] : null;
    }