Gets a generator by name.

@param integer $index get the generator at the given index

@return ReferenceGeneratorInterface|null A ReferenceGeneratorInterface
instance or null when not found
779632
public function get($index)
    {
        if( $index >= count($this->generators) || $index < 0 )
            return null;
          
        return $this->generators[$index];
    }
481660
public function get(int $index)
    {
        $this->internalDataListUpdate();
        if (isset($this->internalDataListData[$index])) {
            return $this->internalDataListUpdateValueIfNeeded($this->internalDataListData, $index);
        }
        return null;
    }
337599
public function nameAtomAt($index)
    {
        $atom = $this->nameAtomAtDefault($index);
        if (null === $atom) {
            throw new Exception\UndefinedAtomException($index);
        }

        return $atom;
    }
547620
public function at($index){
        $return = NULL;
        $index = intval($index);
        $data = $this->asArray();
        reset($data);
        if ($index < 0){
            $index += $this->length();
        }
        $c = 1;
        while ($c <= $index){
            next($data);
            $c++;
        }
        $return = current($data);
        $Model = $this->buildModel($return);
        if ($Model !== NULL){
            $return = $Model;
        }
        return $return;
    }
139968
public function getItem( $index )
    {
        $item = null;

        if ( isset( $this->attributes['items'][$index] ) )
            $item = $this->attributes['items'][$index];

        return $item;
    }
149175
public function getPartByIndex($index)
    {
        if (!isset($this->_parts[$index])) {
            return null;
        }

        $part = $this->_parts[$index];
        $part->parent = $this;

        return $part;
    }
285366
public function getIndexes(): \Generator
    {
        $definitions = $this->reflection->getProperty('indexes') ?? [];

        foreach ($definitions as $definition) {
            yield $this->castIndex($definition);
        }
    }
995434
public function getFiltersTargetedArgs($index = 0)
    {
        return $this->propertyFilters !== null ? $this->propertyFilters->getFiltersTargetedArgs($index) : null;
    }
239897
public function get($index)
    {
        $result = \array_slice($this->nodes, $index, 1); // note: index can be negative
        if (\count($result) > 0) {
            return $result[0];
        }

        return null; // return null if no result for key
    }
57558
public function getRow($index)
    {
        return isset($this->rows[$index]) ? $this->rows[$index] : null;
    }
439772
public function getRow($index)
    {
        $keys = array_keys($this->rows);

        return isset($keys[$index]) ? $this->rows[$keys[$index]] : null;
    }
780425
public function get($index)
    {
        if (!isset($this->_streams[$index])) {
            throw new InvalidArgumentException("Unexisting stream index `{$index}`.");
        }
        return $this->_streams[$index];
    }
1372814
public function get($index = 0)
    {

        if (is_int($index)) {
            if ($index + 1 > $this->count()) {
                return null;
            } else {
                return current(array_slice($this->_items, $index, 1));
            }
        } else {

            if ($index instanceof \MongoId) {
                $index = (string) $index;
            }

            if ($this->has($index)) {
                return $this->_items[$index];
            }
        }

        return null;
    }
228520
protected function getModelFromPathElement($index)
    {
        $pathElement = $this->elements[$index];

        $name = Str::snake(pluralize($pathElement->elementName()));

        $table = $this->spec->findTable($name);
        if (!empty($table)) {
            return $table->getModelName();
        }

        $name = Str::snake(singularize($pathElement->elementName()));
        if (array_key_exists($name, self::SPECIAL_PATH_NAMES)) {
            return self::SPECIAL_PATH_NAMES[$name]['model'];
        }

        return 'User';
    }
36762
public function get($index)
    {
        if (\array_key_exists($index, $this->arrCollection)) {
            return $this->arrCollection[$index];
        }

        return null;
    }
1016317
public function getAttribute(int $index) : ?Node
    {
        return isset($this->attributes[$index]) ? $this->attributes[$index] : null;
    }
483904
public static function get($name)
    {
        if (!isset(static::$idGenerators[$name])) {
            if (!static::has($name)) {
                throw new \InvalidArgumentException(sprintf('The id generator "%s" does not exists.', $name));
            }

            static::$idGenerators[$name] = new static::$map[$name];
        }

        return static::$idGenerators[$name];
    }