Returns the list of object state identifiers separated by group.

@return string[][]
175644
private function loadStateIdentifiers(): array
    {
        if ($this->stateIdentifiers === null) {
            $this->stateIdentifiers = $this->repository->sudo(
                static function (Repository $repository): array {
                    $stateIdentifiers = [];

                    $stateGroups = $repository->getObjectStateService()->loadObjectStateGroups();
                    foreach ($stateGroups as $stateGroup) {
                        $stateIdentifiers[$stateGroup->identifier] = [];

                        $states = $repository->getObjectStateService()->loadObjectStates($stateGroup);
                        foreach ($states as $state) {
                            $stateIdentifiers[$stateGroup->identifier][] = $state->identifier;
                        }
                    }

                    return $stateIdentifiers;
                }
            );
        }

        return $this->stateIdentifiers;
    }
511442
public function getDescendantStates()
    {
        $states = array();

        foreach ($this->getDescendants('SwatState') as $id => $object) {
            $states[$id] = $object->getState();
        }

        return $states;
    }
733448
private function getObjectStateGroupsIds(array $groups): array
    {
        $groupsIds = array_column($groups, 'id');

        return array_combine($groupsIds, array_fill_keys($groupsIds, false));
    }
855441
protected function identifiersToArray(): array
    {
        $data = [];

        foreach ($this->getIdentifiers() as $identifier)
        {
            $data[] = $identifier->toArray();
        }

        return $data;
    }
958909
protected function extractAutoIDs()
    {
        $arr_ids = [];
        foreach($this->obj_last_response->getDeprecatedMutationResult()->getInsertAutoIdKeyList() as $obj_key) {
            $arr_key_path = $obj_key->getPathElementList();
            $obj_path_end = end($arr_key_path);
            $arr_ids[] = $obj_path_end->getId();
        }
        return $arr_ids;
    }
617618
protected function getIDListFromCache() : array
    {
        $arCacheTags = $this->getCacheTagList();
        $sCacheKey = $this->getCacheKey();

        $arElementIDList  = (array) CCache::get($arCacheTags, $sCacheKey);

        return $arElementIDList;
    }
827588
public function getGroupIdArr()
    {
        $return = [];
        if ($this->group_ids) {
            $return = array_filter(StringHelper::explode($this->group_ids, ',', true, true), function ($groupId) {
                return is_numeric($groupId) && DpAdminGroup::find()->findByGroupId($groupId)->exists();
            });
        }

        return $return;
    }
1182460
public function propertiesIdents()
    {
        $metadata = $this->proto()->metadata();
        if (isset($metadata['admin']['lists'])) {
            $adminMetadata   = $metadata['admin'];
            $collectionIdent = $this->collectionIdent();
            if (isset($adminMetadata['lists'][$collectionIdent]['properties'])) {
                return $adminMetadata['lists'][$collectionIdent]['properties'];
            }
        }

        return [];
    }
204990
public String[] getIdentifiers()
	{
		final PerSessionInfo[] infos;
		synchronized (sessions)
		{
			infos = (PerSessionInfo[]) sessions.values().toArray(new PerSessionInfo[sessions.size()]);
		}
		int count = 0;
		for (int i = 0; i < infos.length; ++i)
		{
			if (infos[i] != null && infos[i].identifier != null)
			{
				++count;
			}
		}
		if (count > 0)
		{
			final String[] result = new String[count];
			int index = 0;
			for (int i = 0; i < infos.length; ++i)
			{
				if (infos[i] != null && infos[i].identifier != null)
				{
					result[index++] = infos[i].identifier;
				}
			}
			return result;
		} else
		{
			return null;
		}
	}
407264
public function getIncludeUserIds()
    {
        if ($this->receiver !== null) {
            $ids = array($this->receiver->getId());
        } else {
            $ids = $this->receiverGroup->getUserIds();
        }

        if ($this->workspaceOwners) {
            foreach ($this->workspaceOwners as $owner) {
                $ids[] = $owner->getId();
            }
        }

        return array_unique($ids);
    }
36432
public static function getGroupedTimeZones(): array
	{
		$timeZones = [];

		foreach(static::listIdentifiers() as $timeZone)
		{
			[$group, $city] = explode('/', $timeZone, 2) + [null, null];

			$timeZones[$group][$timeZone] = str_replace('_', ' ', $city);
		}

		unset($timeZones['UTC']);

		return $timeZones;
	}
387614
public function getObjectNames()
    {
        $objectNames = array();
        if (is_array($this->configuration)) {
            $objectNames = array_keys($this->configuration);
        }

        return $objectNames;
    }
1349060
protected function createInGroupDefinition()
    {
        return [
            // Close of a grouping. Note that we avoid trouble with the "valid" inclusion of this character at the first
            // position by consuming it in the IN_GROUP_SPECIAL_FIRST state. Therefore, any further occurrences are
            // indeed valid closing of the current character grouping.
            '\]' => function (Stateful $lexer) {
                $lexer->popState();
                return self::T_GROUP_END;
            },
            // A range is CHAR1-CHAR2, where CHAR2 is not the closing of a group ("-" is permitted as the first or
            // last character of a character grouping.
            '.-[^\]]' => self::T_GROUP_RANGE,
            '\[:[a-z]+:\]' => self::T_GROUP_CHARACTER_CLASS,
            '.' => self::T_GROUP_CHARACTER
        ];
    }
474608
private function getObjectStatesIds(array $states): array
    {
        $statesIds = array_column($states, 'id');

        return array_combine($statesIds, array_fill_keys($statesIds, false));
    }
334920
public function getIds()
    {
        $ids = array();
        foreach ($this->vertices as $vertex) {
            $ids []= $vertex->getId();
        }
        return $ids;
    }
140693
public function getStates()
    {
        $states = [];

        if (self::STATE_OFFLINE === $this->_state) {
            $states[] = self::STATE_OFFLINE;
        } elseif (self::STATE_HIDDEN === $this->_state) {
            $states[] = self::STATE_OFFLINE;
            $states[] = self::STATE_HIDDEN;
        } else {
            foreach (self::$STATES as $value) {
                if (0 !== ($this->_state & $value)) {
                    $states[] = $value;
                }
            }
        }

        return $states;
    }
1044707
public function getIds(): array {
        $this->loadMetadata();
        $ids = array();
        foreach ($this->metadata->allResources(RC::idProp()) as $i) {
            $ids[] = $i->getUri();
        }
        return $ids;
    }