LogicTree\Node\Combine

Complexity

Total Complexity

12

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	hasChildren()	0	3	1
A	isInvert()	0	3	1
A	getCount()	0	3	1
A	getOperator()	0	3	1
A	getChildren()	0	3	1
A	setIsInvert()	0	5	1
A	__construct()	0	8	1
A	setOperator()	0	5	1
A	addChild()	0	10	2
A	setChildren()	0	9	2

<?php
/**
 * Copyright © Thomas Klein, All rights reserved.
 * See LICENSE bundled with this library for license details.
 */
declare(strict_types=1);

namespace LogicTree\Node;

use LogicException;
use function count;

final class Combine extends AbstractNode implements CombineInterface
{
    /**
     * @var string
     */
    private $operator;

    /**
     * @var bool
     */
    private $isInvert;

    /**
     * @var NodeInterface[]
     */
    private $nodes;

    /**
     * @param string $operator
     * @param bool $isInvert [optional] Is false by default.
     * @param NodeInterface[] $children [optional] Is empty by default.
     */
    public function __construct(
        string $operator,
        bool $isInvert = null,
        array $children = []
    ) {
        $this->setOperator($operator);
        $this->setIsInvert($isInvert ?? false);
        $this->setChildren($children);
    }

    public function getChildren(): array
    {
        return $this->nodes;
    }

    public function setChildren(array $children): CombineInterface
    {
        $this->nodes = [];

        foreach ($children as $child) {
            $this->addChild($child);
        }

        return $this;
    }

    public function addChild(NodeInterface $condition): CombineInterface
    {
        if ($condition === $this) {

The condition $condition === $this is always false.

            throw new LogicException('Child node cannot be the current instance of itself.');
        }

        $condition->setParent($this);
        $this->nodes[] = $condition;

        return $this;
    }

    public function getCount(): int
    {
        return count($this->getChildren());
    }

    public function hasChildren(): bool
    {
        return $this->getCount() > 0;
    }

    public function isInvert(): bool
    {
        return $this->isInvert;
    }

    public function setIsInvert(bool $isInvert): CombineInterface
    {
        $this->isInvert = $isInvert;

        return $this;
    }

    public function getOperator(): string
    {
        return $this->operator;
    }

    public function setOperator(string $operator): CombineInterface
    {
        $this->operator = $operator;

        return $this;
    }
}