AmaTeam\ElasticSearch\API\Entity\Mapping\PropertyMapping

Complexity

Total Complexity

23

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	setAppendForcedViews()	0	4	1
A	getParent()	0	3	1
A	__construct()	0	7	2
A	shouldAppendForcedViews()	0	3	1
A	setForcedViewNames()	0	4	1
A	setView()	0	4	1
A	requestViews()	0	3	1
A	setDefaultView()	0	4	1
A	requestView()	0	6	2
A	getViews()	0	3	1
A	setProperty()	0	4	1
A	getProperty()	0	3	1
A	getDefaultView()	0	3	1
A	setViews()	0	4	1
A	setParent()	0	4	1
A	getView()	0	3	1
A	getForcedViewNames()	0	3	1
A	merge()	0	17	4

<?php

declare(strict_types=1);

namespace AmaTeam\ElasticSearch\API\Entity\Mapping;

use AmaTeam\ElasticSearch\Utility\Classes;

class PropertyMapping implements PropertyMappingInterface
{
    /**
     * @var string
     */
    private $parent;
    /**
     * @var string
     */
    private $property;
    /**
     * @var PropertyMappingView[]
     */
    private $views = [];
    /**
     * @var PropertyMappingView
     */
    private $defaultView;
    /**
     * @var string[]|null
     */
    private $forcedViewNames;
    /**
     * @var bool
     */
    private $appendForcedViews = true;

    public function __construct(string $parent = null, string $property = null)
    {
        if ($parent) {

The expression $parent of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $this->setParent($parent);
        }
        $this->property = $property;
        $this->defaultView = new PropertyMappingView();
    }

    /**
     * @return string
     */
    public function getParent(): string
    {
        return $this->parent;
    }

    /**
     * @param string $parent
     * @return $this
     */
    public function setParent(string $parent)
    {
        $this->parent = Classes::normalizeAbsoluteName($parent);
        return $this;
    }

    /**
     * @return string
     */
    public function getProperty(): string
    {
        return $this->property;
    }

    /**
     * @param string $property
     * @return $this
     */
    public function setProperty(string $property)
    {
        $this->property = $property;
        return $this;
    }

    /**
     * @return PropertyMappingView[]
     */
    public function getViews(): array
    {
        return $this->views;
    }

    /**
     * @param PropertyMappingView[] $views
     * @return $this
     */
    public function setViews(array $views)
    {
        $this->views = $views;
        return $this;
    }

    public function getView(string $name): ?PropertyMappingViewInterface
    {
        return $this->views[$name] ?? null;
    }

    public function requestView(string $name): PropertyMappingViewInterface
    {
        if (!isset($this->views[$name])) {
            $this->views[$name] = new PropertyMappingView();
        }
        return $this->views[$name];
    }

    /**
     * @param string[] ...$views
     * @return PropertyMappingViewInterface[]
     */
    public function requestViews(string ...$views): array
    {
        return array_map([$this, 'requestView'], $views);
    }

    public function setView(string $name, PropertyMappingView $view): PropertyMapping
    {
        $this->views[$name] = $view;
        return $this;
    }

    public function getDefaultView(): PropertyMappingViewInterface
    {
        return $this->defaultView;
    }

    /**
     * @param PropertyMappingView $defaultView
     * @return $this
     */
    public function setDefaultView(PropertyMappingView $defaultView)
    {
        $this->defaultView = $defaultView;
        return $this;
    }

    /**
     * @return null|string[]
     */
    public function getForcedViewNames(): ?array
    {
        return $this->forcedViewNames;
    }

    /**
     * @param string[] $forcedViewNames
     * @return $this
     */
    public function setForcedViewNames(array $forcedViewNames)
    {
        $this->forcedViewNames = $forcedViewNames;
        return $this;
    }

    /**
     * @return bool
     */
    public function shouldAppendForcedViews(): bool
    {
        return $this->appendForcedViews;
    }

    /**
     * @param bool $appendForcedViews
     * @return $this
     */
    public function setAppendForcedViews(bool $appendForcedViews)
    {
        $this->appendForcedViews = $appendForcedViews;
        return $this;
    }

    public static function merge(PropertyMappingInterface ...$sources): PropertyMapping
    {
        $target = new PropertyMapping();
        foreach ($sources as $source) {
            $target->setParent($source->getParent());
            $target->setProperty($source->getProperty());
            if ($source->getForcedViewNames() !== null) {
                $target->setForcedViewNames($source->getForcedViewNames());
            }
            $target->setAppendForcedViews($source->shouldAppendForcedViews());
            $defaultView = PropertyMappingView::merge($target->getDefaultView(), $source->getDefaultView());
            $target->setDefaultView($defaultView);
            foreach ($source->getViews() as $name => $view) {
                $target->setView($name, PropertyMappingView::merge($target->requestView($name), $view));
            }
        }
        return $target;
    }
}