Loads data for section with $identifier.

@param string $identifier

@return string[][]
961722
public function loadSectionDataByIdentifier($identifier)
    {
        try {
            return $this->innerGateway->loadSectionDataByIdentifier($identifier);
        } catch (DBALException $e) {
            throw new RuntimeException('Database error', 0, $e);
        } catch (PDOException $e) {
            throw new RuntimeException('Database error', 0, $e);
        }
    }
1237189
static function fetchPartByIdentifier( $identifier )
    {
        $parts = eZNavigationPart::fetchList();

        if ( isset( $parts[$identifier] ) )
            return $parts[$identifier];

        // Return the first part which is the default
        if ( isset( $parts[0] ) )
            return $parts[0];

        return false;
    }
130011
protected function getIdentifierRepresentation(IdentifierInterface $identifier): array
    {
        // it's odd not to have actual ID for identifier (which is OK for newly created resource).
        \assert($identifier->getId() !== null);

        return $identifier->hasIdentifierMeta() === false ? [
            DocumentInterface::KEYWORD_TYPE => $identifier->getType(),
            DocumentInterface::KEYWORD_ID   => $identifier->getId(),
        ] : [
            DocumentInterface::KEYWORD_TYPE => $identifier->getType(),
            DocumentInterface::KEYWORD_ID   => $identifier->getId(),
            DocumentInterface::KEYWORD_META => $identifier->getIdentifierMeta(),
        ];
    }
998495
public function getContentById($identifier, $default = null)
    {
        $this->assertion->keyExists(
            $this->registry[$this->section],
            $identifier,
            'Requested item ('. $identifier .') is not registered in the current registry.'
        );

        return $this->registry[$this->section][$identifier];
    }
387571
public function retrieveByID($identifier)
	{
		$result = @ldap_read($this->conn, $identifier, '(objectclass=*)', $this->config['attributes']);
		if ($result === FALSE)
			return null;

		$entries = ldap_get_entries($this->conn, $result);
		if ($entries['count'] == 0 || $entries['count'] > 1)
			return null;

		return $this->clean($entries[0]);
	}
796058
public function loadGroupDataByIdentifier($identifier)
    {
        try {
            return $this->innerGateway->loadGroupDataByIdentifier($identifier);
        } catch (DBALException $e) {
            throw new RuntimeException('Database error', 0, $e);
        } catch (PDOException $e) {
            throw new RuntimeException('Database error', 0, $e);
        }
    }
654684
public function _getRecords($identifier, $limit, $offset) {
		return $this->Table
			->find()
			->where([$this->Table->alias() . '.model' => $identifier])
			->limit($limit)
			->offset($offset)
			->all();
	}
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;
    }
572665
protected function _parseIdentifier($identifier)
    {
        $parts = array();

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

        return $parts;
    }
670285
public function loadIdentifier($identifier)
    {
        $result = false;

        $identifier = AnService::getIdentifier($identifier);

        //Get the path
        $path = $identifier->filepath;

        if ($path !== false) {
            $result = self::loadFile($path);
        }

        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;
    }
144008
public function getJobFromId($identifier)
    {
        return array_key_exists($identifier, $this->identifierToId)
            ? $this->jobs[$identifier]
            : null;
    }
630900
public function create($name, $identifier)
    {
        $section = new Section();

        $section->name = $name;
        $section->identifier = $identifier;

        $section->id = $this->sectionGateway->insertSection($name, $identifier);

        return $section;
    }
45994
protected function findTagsByIdentifier(string $identifier): array
    {
        $success = false;
        $tags = apcu_fetch($this->identifierPrefix . 'ident_' . $identifier, $success);
        return ($success ? (array)$tags : []);
    }
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);
    }
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;
    }