Gets all the fixture IDs suitable for the given value.

@return string[]
184782
private function getSuitableIds(
        FixtureMatchReferenceValue $value,
        ResolvedFixtureSet $fixtureSet,
        GenerationContext $context
    ): array {
        $pattern = $value->getValue();

        try {
            $cache = $context->getCachedValue(self::IDS_BY_PATTERN_CACHE_KEY);
        } catch (CachedValueNotFound $exception) {
            $cache = [];
        }

        if (array_key_exists($pattern, $cache)) {
            return $cache[$pattern];
        }

        $suitableIds = $this->findSuitableIds($pattern, $fixtureSet);

        $cache[$pattern] = $suitableIds;
        $context->cacheValue(self::IDS_BY_PATTERN_CACHE_KEY, $cache);

        return $suitableIds;
    }
392880
private function initFixtures($data)
    {
        $fixtures = [];
        $parser = $this->container->get('kunstmaan_fixtures.parser.parser');

        foreach ($data as $file) {
            foreach ($file as $class => $specs) {
                foreach ($specs as $name => $options) {
                    $fixture = new Fixture($name, $class, $options);
                    $fixtures = $parser->parseSpec($name, $fixture, $fixtures);
                }
            }
        }

        return $fixtures;
    }
551418
public function getAvailableIDs(): array
    {
        if ($this->availableTz === null) {
            $this->availableTz = [];
            $available = $this->timeZoneClass->getAvailableIDs();
            foreach ($available as $id) {
                $this->availableTz[] = $id;
            }
        }

        return $this->availableTz;
    }
1176124
protected function parseIds($value)
    {
        if ($value instanceof Model) {
            return [$value->{$this->relatedKey}];
        }

        if ($value instanceof Collection) {
            return $value->pluck($this->relatedKey)->all();
        }

        if ($value instanceof BaseCollection) {
            return $value->toArray();
        }

        return (array) $value;
    }
1265280
protected function parseValue($value)
    {
        if (substr($value, 0, 2) == '=>') {
            // Parse a dictionary reference - used to set foreign keys
            if (strpos($value, '.') !== false) {
                list($class, $identifier) = explode('.', substr($value, 2), 2);
            } else {
                throw new \LogicException("Bad fixture lookup identifier: " . $value);
            }

            if ($this->fixtures && !isset($this->fixtures[$class][$identifier])) {
                throw new InvalidArgumentException(sprintf(
                    'No fixture definitions found for "%s"',
                    $value
                ));
            }

            return $this->fixtures[$class][$identifier];
        } else {
            // Regular field value setting
            return $value;
        }
    }
369685
public static function get_config_ids() {
		$configs = [];
		foreach ( self::$instances as $instance ) {
			$configs[] = $instance->id;
		}
		return array_unique( $configs );
	}
80983
protected function findOrphanedIds(): array
    {
        $queryBuilder = $this->entityManager->createQueryBuilder();
        $queryBuilder->select('cc.id AS id')
                     ->from(CraftingCategory::class, 'cc')
                     ->leftJoin('cc.machines', 'm')
                     ->leftJoin('cc.recipes', 'r')
                     ->andWhere('m.id IS NULL')
                     ->andWhere('r.id IS NULL');

        $result = [];
        foreach ($queryBuilder->getQuery()->getResult() as $data) {
            $result[] = (int) $data['id'];
        }
        return $result;
    }
914515
public function getFlattenValidators()
    {
        if (!$this->exists) {
            return [];
        }

        $validators = $this->validators;
        $return     = [];
        if (!empty($validators)) {
            foreach ($validators as $validator) {
                $return[$validator->validator_id] = $validator->value;
            }
        }
        return $return;
    }
1033713
public function idsToNames()
    {
        $names = $this->ifDescriptions();
        $ids   = $this->ifVlanIds();

        $ids   = array_intersect_key( $ids, $names );
        $names = array_intersect_key( $names, $ids );

        return( array_combine( $ids, $names ) );
    }
362475
public function getNode($fixtureId, array $fixtures)
    {
        /** strip @ */
        $fixtureId = substr($fixtureId, 1);

        if (!array_key_exists($fixtureId, $fixtures)) {
            return null;
        }

        /** @var Fixture $fixture */
        $fixture = $fixtures[$fixtureId];
        $additionalEntities = $fixture->getAdditionalEntities();

        if (array_key_exists('rootNode', $additionalEntities)) {
            return $additionalEntities['rootNode'];
        }

        return null;
    }
431247
public function getRawValue(): array
	{
		$primaryValues = [];
		foreach ($this->getIterator() as $entity) {
			if ($entity->isPersisted()) {
				$primaryValues[] = $entity->getValue('id');
			}
		}
		return $primaryValues;
	}
35992
public function getVariableRefs()
	{
		$result = $this->dateXPath2expression instanceof XPath2Expression
			? $this->dateXPath2expression->getParameterQNames()
			: array();

		if ( $this->timeXPath2expression && $this->timeXPath2expression instanceof XPath2Expression )
		{
			$result = array_merge( $result, $this->timeXPath2expression->getParameterQNames() );
		}

		return $result;
	}
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;
    }
409817
public static function getAll() : array
    {
        return [
            self::RSA_SHA256,
            self::RSA_SHA384,
            self::RSA_SHA512,
            self::SHA256,
            self::SHA384,
            self::SHA512
        ];
    }
381106
public function callIds()
    {
      $call_ids = array();	

      foreach ($this->calls as $call)
        $call_ids[] = $call->id;

      return $call_ids;
    }
270060
public function getBindValuesCOMMON()
    {
        $bind_values = $this->bind_values;
        $i           = 1;
        foreach ($this->bind_where as $val) {
            $bind_values[$i] = $val;
            $i++;
        }
        return $bind_values;
    }
1051746
protected function _getAllIndices()
    {
        $out = array();

        foreach ($this->_thread as $val) {
            $out += $val;
        }

        return array_keys($out);
    }