Zerg\Field\Arr

Complexity

Total Complexity

22

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	2	Features	2

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	parse()	0	12	3
A	getCount()	0	4	1
A	setCount()	0	5	1
A	getUntil()	0	4	1
A	setUntil()	0	5	1
A	getField()	0	8	2
A	setField()	0	8	2
A	current()	0	4	1
A	next()	0	4	1
A	key()	0	4	1
A	valid()	0	8	3
A	rewind()	0	4	1
A	isUntilEof()	0	5	2

<?php

namespace Zerg\Field;

use Zerg\Stream\AbstractStream;

/**
 * Class Arr repeat given field needed times.
 *
 * This field return array of values, that are read from Stream by given field,
 * specified count of times, or until some condition are performed.
 *
 * @since 1.0
 * @package Zerg\Field
 */
class Arr extends Collection
{
    /**
     * @var int Count of elements.
     */
    protected $count;

    /**
     * @var string|callable
     */
    protected $until;

    /**
     * @var array|AbstractField Field to be repeated.
     */
    protected $field;

    /**
     * @var int
     */
    protected $index;

    public function __construct($count, $field = [], $options = [])
    {
        $this->index = 0;
        if (is_array($count)) {
            $this->configure($count);
        } else {
            $this->setCount($count);
            $this->setField($field);
            $this->configure($options);
        }
    }

    /**
     * Call parse method on arrayed field needed times.
     *
     * @api
     * @param AbstractStream $stream Stream from which children read.
     * @return array Array of parsed values.
     * @since 1.0
     */
    public function parse(AbstractStream $stream)
    {
        try {
            return parent::parse($stream);
        } catch (\OutOfBoundsException $e) {
            if ($this->isUntilEof()) {
                return $this->dataSet->getData();
            }

            throw $e;
        }
    }

    /**
     * @return int
     */
    public function getCount()
    {
        return (int) $this->resolveProperty('count');
    }

    /**
     * @param int $count
     * @return $this
     */
    public function setCount($count)
    {
        $this->count = $count;
        return $this;
    }

    /**
     * @return callable|string
     */
    public function getUntil()
    {
        return $this->until;
    }

    /**
     * @param callable|string $until
     * @return $this
     */
    public function setUntil($until)
    {
        $this->until = $until;
        return $this;
    }

    /**
     * @return AbstractField

Should the return type not be AbstractField|null?

     */
    public function getField()
    {
        $field = $this->resolveProperty('field');
        if (is_array($field)) {
            $field = Factory::get($field);
        }
        return $field;
    }

    /**
     * @param array|AbstractField $field
     * @return $this
     */
    public function setField($field)
    {
        if (is_array($field)) {
            $field = Factory::get($field);
        }
        $this->field = $field;
        return $this;
    }

    /**
     * @inheritdoc
     * @return AbstractField

Should the return type not be AbstractField|null?

     */
    public function current()
    {
        return $this->getField();
    }

    /**
     * @inheritdoc
     */
    public function next()
    {
        $this->index++;
    }

    /**
     * @inheritdoc
     */
    public function key()
    {
        return $this->index;
    }

    /**
     * @inheritdoc
     */
    public function valid()
    {
        if (is_callable($this->getUntil())) {
            $value = $this->getDataSet()->getValueByCurrentPath();
            return call_user_func($this->getUntil(), end($value));
        }
        return $this->index < $this->getCount() || $this->isUntilEof();
    }

    /**
     * @inheritdoc
     */
    public function rewind()
    {
        $this->index = 0;
    }

    /**
     * Whether array must read until end of file.
     *
     * @return bool
     */
    private function isUntilEof()
    {
        $until = $this->getUntil();
        return is_string($until) && strtolower($until) === 'eof';
    }
}