Loads data for an object state group by identifier.

@param string $identifier

@return array
963195
public function loadObjectStateGroupDataByIdentifier($identifier)
    {
        $query = $this->createObjectStateGroupFindQuery();
        $query->where(
            $query->expr->eq(
                $this->dbHandler->quoteColumn('identifier', 'ezcobj_state_group'),
                $query->bindValue($identifier, null, \PDO::PARAM_STR)
            )
        );

        $statement = $query->prepare();
        $statement->execute();

        return $statement->fetchAll(\PDO::FETCH_ASSOC);
    }
1346974
public function loadCollectionReferencesData(Block $block, ?string $identifier = null): array
    {
        $query = $this->connection->createQueryBuilder();
        $query->select('block_id', 'block_status', 'collection_id', 'collection_status', 'identifier')
            ->from('ngbm_block_collection')
            ->where(
                $query->expr()->eq('block_id', ':block_id')
            )
            ->setParameter('block_id', $block->id, Type::INTEGER)
            ->orderBy('identifier', 'ASC');

        $this->applyStatusCondition($query, $block->status, 'block_status');

        if ($identifier !== null) {
            $query->andWhere($query->expr()->eq('identifier', ':identifier'))
                ->setParameter('identifier', $identifier, Type::STRING);
        }

        return $query->execute()->fetchAll(PDO::FETCH_ASSOC);
    }
350639
public function getDefinition($identifier)
    {
        // Identifier is a php attribute
        if (isset($this->definitions[$identifier])) {
            return $this->definitions[$identifier];
        }

        // Identifier is a MongoDB Key
        if (isset($this->mongoIndex[$identifier])) {
            return $this->definitions[$this->mongoIndex[$identifier]];
        }

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

        return $found_entities->getFirst();
    }
473696
public function findByIdentifier($identifier)
    {
        $object = $this->persistenceManager->getObjectByIdentifier($identifier, $this->entityClassName);
        if ($object === null) {
            foreach ($this->addedResources as $addedResource) {
                if ($this->persistenceManager->getIdentifierByObject($addedResource) === $identifier) {
                    $object = $addedResource;
                    break;
                }
            }
        }

        return $object;
    }
1069435
public function readScopeIdentifiers(string $identifier): array
    {
        try {
            $schema = $this->getDatabaseSchema();
            return $this->readBelongsToManyRelationshipIdentifiers(
                $identifier,
                $schema->getClientsScopesTable(),
                $schema->getClientsScopesClientIdentityColumn(),
                $schema->getClientsScopesScopeIdentityColumn()
            );
        } catch (RepositoryException $exception) {
            $message = 'Reading client scope identifiers failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
1290264
public function get($identifier)
    {
        if (!isset($this->languages[$identifier])) {
            return null;
        }

        return $this->languages[$identifier];
    }
764959
public function offsetGet($identifier)
    {
        $keys = $this->_parseIdentifier($identifier);

        $result = $this->toArray();
        foreach($keys as $key)
        {
            if(is_array($result) && array_key_exists($key, $result)) {
                $result = $result[$key];
            } else {
                $result = null;
                break;
            }
        }

        return $result;
    }
243569
public function get($identifier)
	{
		if (!isset($this->configs[$identifier])) {
			$files = $this->path->find('config.' . $identifier, false);
			
			$config = array();
			foreach ($files as $file) {
				$fileContent = include($file);
				$fileContent = $fileContent ? $fileContent : array();
				$config = array_merge($config, $fileContent);
			}
			
			$this->config[$identifier] = $config;
		}

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

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

        return $result;
    }
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;
    }
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;
    }
331783
public function get($identifier)
    {
        if ($this->themeLoaded === false) {
            $this->loadThemes();
        }

        return $this->themeList->get($identifier);
    }
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];
    }
1247557
public static function read( $identifier )
    {
        // Fetch which storage driver to use
        $driver = self::getDriver($identifier);
        if (!$driver) return null;

        // Fetch the data type & formatter
        $type = forward_static_call(array($driver, 'getType'), $identifier);
        if(!in_array($type, self::$supported)) return null;
        $formatter = self::$formatMap[$type];

        // Fetch the contents of the identifier
        $contents = forward_static_call(array($driver, 'read'), $identifier);
        if(!$contents) return null;

        // Decode the data
        return forward_static_call(array($formatter, 'decode'), $contents);
    }
318732
public function loadTypeDataByIdentifier($identifier, $status)
    {
        $q = $this->getLoadTypeQueryBuilder();
        $q
            ->where($q->expr()->eq('c.identifier', ':identifier'))
            ->andWhere($q->expr()->eq('c.version', ':version'))
            ->setParameter('identifier', $identifier, ParameterType::STRING)
            ->setParameter('version', $status, ParameterType::INTEGER);

        return $q->execute()->fetchAll();
    }
1033511
public function retrieve($identifier)
    {
        $profileData = $this->collection->findOne([
            'identifier' => $identifier,
        ]);

        if($profileData !== null) {
            return $this->createProfileFromProfileData($profileData['profile']);
        }

        return null;
    }