Wszetko\Sitemap\Items\DataTypes\ArrayType

Complexity

Total Complexity

24

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Test Coverage

Coverage

98%

Importance

Changes	1
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	addValue()	0	16	4
A	setValue()	0	11	3
A	setMaxElements()	0	5	1
A	getMaxElements()	0	3	1
A	getBaseDataType()	0	3	1
A	__construct()	0	12	2
C	getValue()	0	37	12

<?php

declare(strict_types=1);

/**
 * This file is part of Wszetko Sitemap.
 *
 * (c) Paweł Kłopotek-Główczewski <pawelkg@pawelkg.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Wszetko\Sitemap\Items\DataTypes;

use InvalidArgumentException;
use Wszetko\Sitemap\Interfaces\DataType;

/**
 * Class ArrayType.
 *
 * @package Wszetko\Sitemap\Items\DataTypes
 */
class ArrayType extends AbstractDataType
{
    /**
     * @var null|int
     */
    protected $maxElements;

    /**
     * @var \Wszetko\Sitemap\Items\DataTypes\AbstractDataType
     */
    private $baseDataType;

    /**
     * ArrayType constructor.
     *
     * @param mixed $name
     * @param mixed $dataType
     *
     * @throws \InvalidArgumentException
     */
    public function __construct($name, $dataType)
    {
        parent::__construct($name);

        $baseDataType = new $dataType($this->getName());

        if (($baseDataType instanceof AbstractDataType) === false) {
            throw new InvalidArgumentException('Provided DataType is invalid.');
        }

        $this->baseDataType = $baseDataType;
        $this->value = [];
    }

    /**
     * @return \Wszetko\Sitemap\Items\DataTypes\AbstractDataType
     */
    public function getBaseDataType(): AbstractDataType
    {
        return $this->baseDataType;
    }

    /**
     * @return null|int
     */
    public function getMaxElements(): ?int
    {
        return $this->maxElements;
    }

    /**
     * @param int $maxElements
     *
     * @return self
     */
    public function setMaxElements(int $maxElements): self
    {
        $this->maxElements = $maxElements;

        return $this;
    }

    /**
     * @param mixed $value
     * @param array $parameters
     *
     * @return static
     */
    public function setValue($value, $parameters = []): DataType
    {
        if (is_array($value)) {
            foreach ($value as $val) {
                $this->addValue($val, $parameters);
            }
        } else {
            $this->addValue($value, $parameters);
        }

        return $this;
    }

    /**
     * @param mixed $value
     * @param array $parameters
     *
     * @return \Wszetko\Sitemap\Interfaces\DataType
     */
    public function addValue($value, $parameters = []): DataType
    {
        if (is_array($value)) {
            foreach ($value as $val) {
                $this->addValue($val, $parameters);
            }
        } else {
            $var = clone $this->getBaseDataType();
            $var->setValue($value, $parameters);

            if (null !== $var->getValue()) {
                $this->value[] = $var;
            }
        }

        return $this;
    }

    /**
     * @return mixed
     */
    public function getValue()
    {
        $values = parent::getValue();

        if (null === $values || [] === $values) {
            return null;
        }

        $result = [];

        if (is_array($values)) {
            /** @var DataType $element */
            foreach ($values as $element) {
                $this->propagateDomain($element);
                $value = $element->getValue();

                if (
                    is_array($value) &&
                    isset(array_values($value)[0]) &&
                    '' !== array_values($value)[0]
                ) {
                    $key = array_key_first($value);

                    if (null !== $key) {
                        $result[$key] = array_values($value)[0];
                    }
                } elseif (null !== $value && '' !== $value) {
                    $result[] = $value;
                }
            }

            if (null !== $this->getMaxElements()) {
                $result = array_slice($result, 0, $this->getMaxElements());
            }
        }

        return $result;
    }
}