Xsolve\Associate\BufferedCollector\BufferedCollector

Complexity

Total Complexity

7

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	createCollectClosure()	0	11	2
A	resolveSimilar()	0	20	4

<?php

namespace Xsolve\Associate\BufferedCollector;

use Xsolve\Associate\CollectorInterface;
use Xsolve\Associate\Metadata\MetadataWrapperProvider;
use Xsolve\Associate\ObjectCollection\UniqueObjectCollection;

class BufferedCollector implements BufferedCollectorInterface
{
    /**
     * @var MetadataWrapperProvider
     */
    protected $metadataWrapperProvider;

    /**
     * @var CollectorInterface
     */
    protected $collector;

    /**
     * @var BufferedCollect[]
     */
    protected $bufferedCollects = [];

    /**
     * @param MetadataWrapperProvider $metadataWrapperProvider
     * @param CollectorInterface      $collector
     */
    public function __construct(
        MetadataWrapperProvider $metadataWrapperProvider,
        CollectorInterface $collector
    ) {
        $this->metadataWrapperProvider = $metadataWrapperProvider;
        $this->collector = $collector;
    }

    /**
     * @param array    $objects
     * @param string[] $associationPath
     *
     * @return \Closure
     */
    public function createCollectClosure(array $objects, array $associationPath): \Closure
    {
        $bufferedCollect = new BufferedCollect($objects, $associationPath);
        $this->bufferedCollects[] = $bufferedCollect;

        return function () use ($bufferedCollect) {
            if (!empty($this->bufferedCollects)) {
                $this->resolveSimilar($bufferedCollect);
            }

            return $bufferedCollect->getAssociatedEntities();
        };
    }

    /**
     * @param BufferedCollect $resolvedBufferedCollect
     */
    protected function resolveSimilar(BufferedCollect $resolvedBufferedCollect)
    {
        $resolvedAssociationPath = $resolvedBufferedCollect->getAssociationPath();

        $objects = new UniqueObjectCollection();
        $similarBufferedCollects = [];
        foreach ($this->bufferedCollects as $bufferedCollectKey => $bufferedCollect) {
            if ($bufferedCollect->getAssociationPath()->isEqual($resolvedAssociationPath)) {
                $similarBufferedCollects[] = $bufferedCollect;
                $objects->addMany($bufferedCollect->getObjects());
                unset($this->bufferedCollects[$bufferedCollectKey]);
            }
        }

        // TODO We would only need to fetch as far as last Doctrine association is in case of mixed associations.

        $this->collector->collect($objects->getAll(), $resolvedAssociationPath->getAssociationNames());
        foreach ($similarBufferedCollects as $bufferedCollect) {
            $bufferedCollect->setAssociatedEntities(
                $this->collector->collect($bufferedCollect->getObjects(), $resolvedAssociationPath->getAssociationNames())
            );
        }
    }
}