Daikon\Entity\Entity\RelatedEntityList

Complexity

Total Complexity

16

Size/Duplication

Total Lines	76
Duplicated Lines	100 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	makeEmpty()	4	4	1
A	wrap()	4	4	1
A	fromNative()	4	4	1
A	toNative()	6	6	1
B	equals()	16	16	5
A	__toString()	8	8	2
A	diff()	18	18	4
A	__construct()	4	4	1

<?php

namespace Daikon\Entity\Entity;

use Daikon\DataStructure\TypedListTrait;
use Daikon\Entity\Assert\Assertion;
use Daikon\Entity\ValueObject\ValueObjectInterface;
use Daikon\Entity\ValueObject\ValueObjectListInterface;

final class RelatedEntityList implements ValueObjectListInterface

This class seems to be duplicated in your project.

{
    use TypedListTrait;

    public static function makeEmpty(): self
    {
        return new static;
    }

    public static function wrap($entities): self
    {
        return new self($entities);
    }

    public static function fromNative($nativeValue): self
    {
        // @todo implement
    }

    public function toNative(): array
    {
        return $this->compositeVector->map(function (ValueObjectInterface $entity): array {
            return $entity->toNative();
        })->toArray();
    }

    public function equals(ValueObjectInterface $otherList): bool
    {
        /** RelatedEntityList $otherList */
        if (!$otherList instanceof self) {
            return false;
        }
        if (count($this) !== count($otherList)) {
            return false;
        }
        foreach ($this as $pos => $value) {
            if (!$value->equals($otherList->get($pos))) {
                return false;
            }
        }
        return true;
    }

    public function __toString(): string
    {
        $parts = [];
        foreach ($this as $nestedEntity) {
            $parts[] = (string)$nestedEntity;
        }
        return implode(",\n", $parts);
    }

    public function diff(ValueObjectListInterface $otherList): ValueObjectListInterface
    {
        $differentEntities = [];
        /* @var TypedEntityInterface $entity */
        foreach ($this as $pos => $entity) {
            if (!$otherList->has($pos)) {
                $differentEntities[] = $entity;
                continue;
            }
            /* @var TypedEntityInterface $otherEntity */
            $otherEntity = $otherList->get($pos);
            $diff = $entity->getValueObjectMap()->diff($otherEntity->getValueObjectMap());
            if (!$diff->isEmpty()) {
                $differentEntities[] = $entity;
            }
        }
        return new static($differentEntities);
    }

    private function __construct(array $entities = [])
    {
        $this->init($entities, EntityRelationInterface::class);
    }
}