Check if a user has already been loaded for a given user identifier

@param $identifier
@return boolean TRUE if a user has already been loaded. FALSE otherwise
427081
public function isLoaded($identifier)
    {
        if (!is_numeric($identifier)) {
            $result = isset($this->_emails[$identifier]);
        } else {
            $result = parent::isLoaded($identifier);
        }

        return $result;
    }
869307
public function IdExists($id)
    {
        $property = $this->getUserIdProperty();
        $user = User::where($property, "=", $id)->count();
        return $user === 0 ? false : true;
    }
28771
public function has($identifier)
    {
        $keys = $this->_parseIdentifier($identifier);

        foreach($keys as $key)
        {
            if(array_key_exists($key, $this->_data)) {
                return true;
            };
        }

        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;

    }
1222346
public function getPages($identifier = '')
    {
        if (!empty($identifier)) {
            return $this->hasPage($identifier) ? $this->pages[$identifier] : null;
        }

        return $this->pages;
    }
539711
public function findByIdentifier($identifier): ?User
    {
        return DB::table('user')
            ->where('user_name', '=', $identifier)
            ->orWhere('email', '=', $identifier)
            ->get()
            ->map(User::rowMapper())
            ->first();
    }
1276454
public static function has($identifier)
    {
        try {
            $objIdentifier = self::getIdentifier($identifier);
            $strIdentifier = (string) $objIdentifier;
            $result = (bool) self::$_services->offsetExists($strIdentifier);
        } catch (AnServiceIdentifierException $e) {
            $result = false;
        }

        return $result;
    }
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;

    }
991396
public function findModelByUniqueIdentifier($identifier)
    {
        $this->filter(new Equals($this->getModelSchema()->uniqueIdentifierColumnName, $identifier));

        return $this[0];
    }
806841
public function get($identifier)
    {
        $identifier = (string) $identifier;

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

        return $result;
    }
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;
    }
628994
protected function _query($identifier)
    {
        list(, $userAlias) = pluginSplit($this->_config['userModel']);
        $provider = $this->adapter()->id;

        return $this->_profileModel->find()
            ->where([
                $this->_profileModel->aliasField('provider') => $provider,
                $this->_profileModel->aliasField('identifier') => $identifier
            ]);
    }
1027864
protected function _getCount($identifier) {
		$count = $this->_getCountQuery($identifier)->count();
		if ($count === 0) {
			$this->out(__d('file_storage', 'No records for identifier "{0}" found.', $identifier));
			$this->_stop();
		}

		return $count;
	}
372505
protected function loadProfile($identifier = null)
    {
        if (!$identifier) {
            $identifier = 'generic';
        }

        if (isset($this->profiles[$identifier])) {
            $this->currentProfile = $this->profiles[$identifier];
        } else {
            $this->currentProfile        = new SgProfile();
            $this->profiles[$identifier] = $this->currentProfile;
        }

        return $this->currentProfile;
    }
1218918
public function checkContentTypeGroupExistenceByIdentifier($identifier)
    {
        /** @var \eZ\Publish\API\Repository\ContentTypeService */
        $contentTypeService = $this->contentTypeService;

        // attempt to load the content type group with the identifier
        try {
            $contentTypeService->loadContentTypeGroupByIdentifier($identifier);
            return true;
        } catch (ApiExceptions\NotFoundException $e) {
            return false;
        }
    }
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();
    }
952176
public function addIdentifier(string $identifier)
    {
        $count = $this->queueRepository->countOpenByIdentifier($identifier);
        if ($count > 0) {
            return;
        }

        $this->logger->debug('SFC Queue add', [$identifier]);

        $data = [
            'cache_url' => $identifier,
            'page_uid' => 0,
            'invalid_date' => \time(),
            'call_result' => '',
        ];

        $this->queueRepository->insert($data);
    }