Возвращает объект reader'а конфигурации.
@return IReader
@throws OutOfBoundsException если необходимый reader не доступен
486088
protected function getReader()
    {
        if (!isset($this->readers[$this->type])) {
            throw new OutOfBoundsException($this->translate(
                'Reader "{type}" is not available.',
                ['type' => $this->type]
            ));
        }

        return $this->getPrototype($this->readers[$this->type], ['umi\config\io\reader\IReader'])->createSingleInstance();
    }
609836
public function offsetGet($offset)
	{
		if(empty($this->tokens[$offset]))
		{
			throw new \OutOfBoundsException('No token found at offset ' . $offset);
		}

		return $this->tokens[$offset];
	}
1078189
public function getHooksAnnotationReader() {
		$AnnotationReader = new \Asgard\Hook\AnnotationReader;
		if($this->getCache())
			$AnnotationReader->setCache($this->getCache());
		$AnnotationReader->setDebug($this->getConfig()['debug']);
		return $AnnotationReader;
	}
16340
public function getMetadataReader()
    {
        if ($this->metadataReader === null) {
            $this->setMetadataReader($this->getDefaultMetadataReader());
        }

        return $this->metadataReader;
    }
383366
public function getCount($primaryKey)
    {
        if (!isset($this->values[$primaryKey])) {
            throw new OutOfBoundsException(sprintf(
                'The key "%s" does not exist.',
                $primaryKey
            ));
        }

        return count($this->values[$primaryKey]);
    }
116218
public function getIterator()
    {
        if (!file_exists($this->filepath)) {
            //TODO: throw exception instead?
            return null;
        }
        $header = $this->hasheader ? $this->getFirstRow() : null;
        $output = array();

        $config = new LexerConfig();
        $config->setDelimiter($this->delimiter);
        $config->setEnclosure($this->enclosure);
        $config->setIgnoreHeaderLine($this->hasheader);

        $interpreter = new Interpreter();
        // Ignore row column count consistency
        $interpreter->unstrict();
        $interpreter->addObserver(function (array $row) use (&$output, $header) {
            if ($header) {
                //create new row using headings as keys
                $newrow = array();
                foreach ($header as $k => $heading) {
                    if (isset($row[$k])) {
                        $newrow[$heading] = $row[$k];
                    }
                }
                $row = $newrow;
            }
            $output[] = $row;
        });

        $lexer = new Lexer($config);
        $lexer->parse($this->filepath, $interpreter);

        return new ArrayIterator($output);
    }
902914
public function removeReader($name)
    {
        if (!$this->hasReader($name)) {
            throw new \OutOfBoundsException(sprintf('Undefined reader "%s"', $name));
        }

        unset($this->readers[$name]);

        return $this;
    }
662930
public final function OneFromReader(DBInterfaces\IDatabaseReader $reader)
    {
        $object = null;
        if($reader->Read())
        {
            $object = $this->CreateInstance($reader[$this->KeyField()]);
            $object->InitFromReader($reader);
        }
        $reader->Close();
        return $object;
    }
15012
public function getReadHandler()
    {
        if (null === $this->stream) {
            $this->stream = fopen($this->uri, 'r');
        }
        return $this->stream;
    }
1129902
public function getMetadataReaderManager()
    {
        if ($this->metadataReaderManager) {
            return $this->metadataReaderManager;
        }

        try {
            $sl = $this->getServiceLocator();
            /** @var ModuleOptions $moduleOptions */
            $moduleOptions = $sl->get(ModuleOptions::class);

            $className = $moduleOptions->getMetadataReaderManagerClassName();

            $r = new \ReflectionClass($className);
            $instance = $r->newInstance();

            if (!$instance instanceof MetadataReaderManagerInterface) {
                $errMsg = sprintf('Metadata reader manager not implement %s', MetadataReaderManagerInterface::class);
                throw new Exception\ErrorInitModuleException($errMsg);
            }
            $this->metadataReaderManager = $instance;
        } catch (\Exception $e) {
            throw new Exception\ErrorInitModuleException($e->getMessage(), $e->getCode(), $e);
        }

        return $this->metadataReaderManager;
    }
1264485
function getIdentity() {
		$cols = array();
		if (count($identity = $this->getTable()->getIdentity())) {
			foreach ($identity as $col) {
				if (!array_key_exists($col, $this->data)) {
					throw new \OutOfBoundsException(
						sprintf("Column '%s' does not exist in row of table '%s'",
							$col, $this->getTable()->getName()
						)
					);
				}
				$cols[$col] = $this->data[$col];
			}
		} else {
			$cols = $this->data;
		}
		return $cols;
	}
41797
private static function getReader(): Reader
    {
        if (self::$annotationReader === null) {
            self::$annotationReader = AspectKernel::getInstance()->getContainer()->get('aspect.annotation.reader');
        }

        return self::$annotationReader;
    }
1006380
public function first()
    {
        if (empty($this->data)) {
            throw new OutOfBoundsException('Can\'t determine first item. Collection is empty');
        }

        \reset($this->data);

        return \current($this->data);
    }
1358289
public function get($version)
    {
        if (!isset($this->versions[$version])) {
            throw new OutOfBoundsException(sprintf(
                'The version %s of path %s does not exist.',
                $version,
                $this->path
            ));
        }

        return $this->versions[$version];
    }
44653
protected function constructReadMethod()
    {
        // Reader methods ends with this.
        $endsWith = 'annotations';

        // We have an annotation name which means
        // we have to target a specific one.
        if ($this->wantsSpecificAnnotation()) {
            $endsWith = 'annotation';
        }

        return Str::camel('get'.$this->target.$endsWith);
    }
1070203
protected function getConfigurationReader()
    {
        // Add required dependencies
        self::$registry->getContainer()->getMap()->wire(
            [
                'doozr.filesystem.service' => Doozr_Loader_Serviceloader::load('filesystem'),
                'doozr.cache.service'      => Doozr_Loader_Serviceloader::load(
                    'cache',
                    DOOZR_CACHING_CONTAINER,
                    DOOZR_NAMESPACE_FLAT.'.cache.i18n',
                    [],
                    DOOZR_UNIX,
                    DOOZR_CACHING
                ),
            ]
        );

        /* @var Doozr_Configuration_Reader_Ini $config */
        $config = self::$registry->getContainer()->build(
            'doozr.configuration.reader.ini',
            [
                DOOZR_CACHING,
            ]
        );

        return $config;
    }
1024528
protected function getAnnotationReader()
    {
        if ($this->packageSupportsLegacyCore()) {
            $reader = $this->getLegacyAnnotationReader();
        } else {
            $reader = $this->getStandardAnnotationReader();
        }
        return $reader;
    }