Xsolve\Associate\Facade

Complexity

Total Complexity

19

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getBufferedDoctrineOrmCollector()	0	10	2
A	__construct()	0	3	1
A	getBasicCollector()	0	9	2
A	getDoctrineOrmCollector()	0	9	2
A	getBasicAssociationCollectingStrategy()	0	13	2
A	assertEntityManagerAvailable()	0	4	2
A	getMetadataWrapperProvider()	0	8	2
A	getEntityManager()	0	7	2
A	getDoctrineOrmEntityLoader()	0	12	2
A	getDoctrineOrmAssociationCollectingStrategy()	0	19	2

<?php

namespace Xsolve\Associate;

use Doctrine\ORM\EntityManagerInterface;
use Xsolve\Associate\AssociationCollecting\BasicAssociationCollectingStrategy;
use Xsolve\Associate\AssociationCollecting\DoctrineOrmAssociationCollectingStrategy;
use Xsolve\Associate\BufferedCollector\BufferedCollector;
use Xsolve\Associate\BufferedCollector\BufferedCollectorInterface;
use Xsolve\Associate\CollectionTraversal\ArrayCollectionTraversalStrategy;
use Xsolve\Associate\CollectionTraversal\DoctrineOrmCollectionCollectionTraversalStrategy;
use Xsolve\Associate\CollectionTraversal\TraversableCollectionTraversalStrategy;
use Xsolve\Associate\Loader\DoctrineOrmEntityLoader;
use Xsolve\Associate\Loader\DoctrineOrmNonProxiedAssociationQueryExecutor;
use Xsolve\Associate\Loader\DoctrineOrmUninitializedProxiesQueryExecutor;
use Xsolve\Associate\Metadata\MetadataWrapperProvider;

// TODO Make separate facade for Doctrine.
class Facade
{
    /**
     * @var EntityManagerInterface|null
     */
    protected $entityManager;

    /**
     * @var MetadataWrapperProvider
     */
    protected $metadataWrapperProvider;

    /**
     * @var BasicAssociationCollectingStrategy
     */
    protected $basicAssociationCollectingStrategy;

    /**
     * @var DoctrineOrmAssociationCollectingStrategy
     */
    protected $doctrineOrmAssociationCollectingStrategy;

    /**
     * @var DoctrineOrmEntityLoader
     */
    protected $doctrineOrmEntityLoader;

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

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

    /**
     * @var BufferedCollector
     */
    protected $bufferedCollector;

    /**
     * @param EntityManagerInterface|null $entityManager
     */
    public function __construct(EntityManagerInterface $entityManager = null)
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @return CollectorInterface
     */
    public function getBasicCollector(): CollectorInterface
    {
        if (!$this->basicCollector instanceof CollectorInterface) {

$this->basicCollector is always a sub-type of Xsolve\Associate\CollectorInterface. If $this->basicCollector can have other possible types, add them to lib/Facade.php:47.

            $this->basicCollector = new Collector(
                $this->getBasicAssociationCollectingStrategy()
            );
        }

        return $this->basicCollector;
    }

    /**
     * @return CollectorInterface
     */
    public function getDoctrineOrmCollector(): CollectorInterface
    {
        if (!$this->doctrineOrmCollector instanceof CollectorInterface) {

$this->doctrineOrmCollector is always a sub-type of Xsolve\Associate\CollectorInterface. If $this->doctrineOrmCollector can have other possible types, add them to lib/Facade.php:52.

            $this->doctrineOrmCollector = new Collector(
                $this->getDoctrineOrmAssociationCollectingStrategy()
            );
        }

        return $this->doctrineOrmCollector;
    }

    /**
     * @return BufferedCollectorInterface
     */
    public function getBufferedDoctrineOrmCollector(): BufferedCollectorInterface
    {
        if (!$this->bufferedCollector instanceof BufferedCollector) {

$this->bufferedCollector is always a sub-type of Xsolve\Associate\BufferedCollector\BufferedCollector. If $this->bufferedCollector can have other possible types, add them to lib/Facade.php:57.

            $this->bufferedCollector = new BufferedCollector(
                $this->getMetadataWrapperProvider(),
                $this->getDoctrineOrmCollector()
            );
        }

        return $this->bufferedCollector;
    }

    /**
     * @return MetadataWrapperProvider
     *
     * @throws \Exception
     */
    protected function getMetadataWrapperProvider(): MetadataWrapperProvider
    {
        $entityManager = $this->getEntityManager();
        if (!$this->metadataWrapperProvider instanceof MetadataWrapperProvider) {

$this->metadataWrapperProvider is always a sub-type of Xsolve\Associate\Metadata\MetadataWrapperProvider. If $this->metadataWrapperProvider can have other possible types, add them to lib/Facade.php:27.

            $this->metadataWrapperProvider = new MetadataWrapperProvider($entityManager);
        }

        return $this->metadataWrapperProvider;
    }

    /**
     * @return BasicAssociationCollectingStrategy
     */
    protected function getBasicAssociationCollectingStrategy(): BasicAssociationCollectingStrategy
    {
        if (!$this->basicAssociationCollectingStrategy instanceof BasicAssociationCollectingStrategy) {

$this->basicAssociationCollectingStrategy is always a sub-type of Xsolve\Associate\AssociationCollecting\BasicAssociationCollectingStrategy. If $this->basicAssociationCollectingStrategy can have other possible types, add them to lib/Facade.php:32.

            $this->basicAssociationCollectingStrategy = new BasicAssociationCollectingStrategy();
            $this->basicAssociationCollectingStrategy->addCollectionTraversalStrategy(
                new ArrayCollectionTraversalStrategy()
            );
            $this->basicAssociationCollectingStrategy->addCollectionTraversalStrategy(
                new TraversableCollectionTraversalStrategy()
            );
        }

        return $this->basicAssociationCollectingStrategy;
    }

    /**
     * @return DoctrineOrmAssociationCollectingStrategy
     */
    protected function getDoctrineOrmAssociationCollectingStrategy(): DoctrineOrmAssociationCollectingStrategy
    {
        if (!$this->doctrineOrmAssociationCollectingStrategy instanceof DoctrineOrmAssociationCollectingStrategy) {

$this->doctrineOrmAssociationCollectingStrategy is always a sub-type of Xsolve\Associate\AssociationCollecting\DoctrineOrmAssociationCollectingStrategy. If $this->doctrineOrmAssociationCollectingStrategy can have other possible types, add them to lib/Facade.php:37.

            $this->doctrineOrmAssociationCollectingStrategy = new DoctrineOrmAssociationCollectingStrategy(
                $this->getMetadataWrapperProvider(),
                $this->getDoctrineOrmEntityLoader()
            );
            $this->doctrineOrmAssociationCollectingStrategy->addCollectionTraversalStrategy(
                new ArrayCollectionTraversalStrategy()
            );
            $this->doctrineOrmAssociationCollectingStrategy->addCollectionTraversalStrategy(
                new TraversableCollectionTraversalStrategy()
            );
            $this->doctrineOrmAssociationCollectingStrategy->addCollectionTraversalStrategy(
                new DoctrineOrmCollectionCollectionTraversalStrategy()
            );
        }

        return $this->doctrineOrmAssociationCollectingStrategy;
    }

    /**
     * @return DoctrineOrmEntityLoader
     */
    protected function getDoctrineOrmEntityLoader(): DoctrineOrmEntityLoader
    {
        if (!$this->doctrineOrmEntityLoader instanceof DoctrineOrmEntityLoader) {

$this->doctrineOrmEntityLoader is always a sub-type of Xsolve\Associate\Loader\DoctrineOrmEntityLoader. If $this->doctrineOrmEntityLoader can have other possible types, add them to lib/Facade.php:42.

            $this->doctrineOrmEntityLoader = new DoctrineOrmEntityLoader(
                $this->getMetadataWrapperProvider(),
                new BasicAssociationCollectingStrategy(),
                new DoctrineOrmUninitializedProxiesQueryExecutor(),
                new DoctrineOrmNonProxiedAssociationQueryExecutor()
            );
        }

        return $this->doctrineOrmEntityLoader;
    }

    /**
     * @throws \Exception
     */
    protected function assertEntityManagerAvailable()
    {
        if (!$this->entityManager instanceof EntityManagerInterface) {
            throw new \Exception('Entity manager not available.');
        }
    }

    /**
     * @return EntityManagerInterface
     *
     * @throws \Exception
     */
    protected function getEntityManager(): EntityManagerInterface
    {
        if (!$this->entityManager instanceof EntityManagerInterface) {
            throw new \Exception('Entity manager not available.');
        }

        return $this->entityManager;
    }
}