Metabor\Statemachine\Factory\Factory

Complexity

Total Complexity

10

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

50%

Importance

Changes	1
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	setMutexFactory()	0	4	1
A	setTransitonSelector()	0	4	1
A	attachStatemachineObserver()	0	4	1
A	detachStatemachineObserver()	0	4	1
A	getStatemachineObserver()	0	4	1
B	createStatemachine()	0	22	4

<?php

namespace Metabor\Statemachine\Factory;

use Metabor\Statemachine\Statemachine;
use MetaborStd\Semaphore\MutexFactoryInterface;
use MetaborStd\Statemachine\Factory\FactoryInterface;
use MetaborStd\Statemachine\Factory\ProcessDetectorInterface;
use MetaborStd\Statemachine\Factory\StateNameDetectorInterface;
use MetaborStd\Statemachine\Factory\TransitionSelectorInterface;

/**
 * @author Oliver Tischlinger
 */
class Factory implements FactoryInterface
{
    /**
     * @var ProcessDetectorInterface
     */
    private $processDetector;

    /**
     * @var StateNameDetectorInterface
     */
    private $stateNameDetector;

    /**
     * @var \SplObjectStorage|\SplObserver[]
     */
    private $statemachineObserver;

    /**
     * @var TransitionSelectorInterface
     */
    private $transitonSelector;

    /**
     * @var MutexFactoryInterface
     */
    private $mutexFactory;

    /**
     * @param ProcessDetectorInterface   $processDetector
     * @param StateNameDetectorInterface $stateNameDetector
     */
    public function __construct(ProcessDetectorInterface $processDetector, StateNameDetectorInterface $stateNameDetector = null)
    {
        $this->processDetector = $processDetector;
        $this->stateNameDetector = $stateNameDetector;
        $this->statemachineObserver = new \SplObjectStorage();
    }

    /**
     * @param MutexFactoryInterface $mutexFactory
     */
    public function setMutexFactory($mutexFactory)
    {
        $this->mutexFactory = $mutexFactory;
    }

    /**
     * @param TransitionSelectorInterface $transitionSelector
     */
    public function setTransitonSelector(TransitionSelectorInterface $transitionSelector)
    {
        $this->transitonSelector = $transitionSelector;
    }

    /**
     * @param \SplObserver $observer
     */
    public function attachStatemachineObserver(\SplObserver $observer)
    {
        $this->statemachineObserver->attach($observer);
    }

    /**
     * @param \SplObserver $observer
     */
    public function detachStatemachineObserver(\SplObserver $observer)
    {
        $this->statemachineObserver->detach($observer);
    }

    /**
     * @return \Traversable
     */
    public function getStatemachineObserver()
    {
        return $this->statemachineObserver;
    }

    /**
     * @param object $subject
     *
     * @return \MetaborStd\Statemachine\StatemachineInterface
     */
    public function createStatemachine($subject)
    {
        $process = $this->processDetector->detectProcess($subject);
        if ($this->stateNameDetector) {
            $stateName = $this->stateNameDetector->detectCurrentStateName($subject);
        } else {
            $stateName = null;
        }
        if ($this->mutexFactory) {
            $mutex = $this->mutexFactory->createMutex($subject);
        } else {
            $mutex = null;
        }

        $statemachine = new Statemachine($subject, $process, $stateName, $this->transitonSelector, $mutex);

        foreach ($this->statemachineObserver as $observer) {
            $statemachine->attach($observer);
        }

        return $statemachine;
    }
}