Metabor\Statemachine\Process

Complexity

Total Complexity

14

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

92.68%

Importance

Changes	10
Bugs	5	Features	3

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	addState()	0	16	4
A	initProcess()	0	4	1
A	createCollection()	0	5	1
A	getInitialState()	0	4	1
A	getStates()	0	4	1
A	getState()	0	4	1
A	hasState()	0	4	1
A	getStateCollectionMerger()	0	8	2
A	merge()	0	5	1

<?php

namespace Metabor\Statemachine;

use Metabor\Named;
use Metabor\Statemachine\Util\SetupHelper;
use Metabor\Statemachine\Util\StateCollectionMerger;
use MetaborStd\MergeableInterface;
use MetaborStd\Statemachine\ProcessInterface;
use MetaborStd\Statemachine\StateInterface;
use MetaborStd\Statemachine\TransitionInterface;

/**
 * @author Oliver Tischlinger
 */
class Process extends Named implements ProcessInterface, MergeableInterface
{
    /**
     * @var StateCollection
     */
    private $states;

    /**
     * @var StateInterface
     */
    private $initialState;

    /**
     * @var StateCollectionMerger
     */
    private $stateCollectionMerger;

    /**
     * @param string         $name
     * @param StateInterface $initialState
     */
    public function __construct($name, StateInterface $initialState)
    {
        parent::__construct($name);
        $this->initialState = $initialState;
        $this->createCollection();
        $this->initProcess(new SetupHelper($this->states));
    }

    /**
     * @param StateInterface $state
     */
    protected function addState(StateInterface $state)
    {
        $name = $state->getName();
        if ($this->states->hasState($name)) {
            if ($this->states->getState($name) !== $state) {
                throw new \Exception('There is already a different state with name "' . $name . '"');
            }
        } else {
            $this->states->addState($state);
            /* @var $transition TransitionInterface */
            foreach ($state->getTransitions() as $transition) {
                $targetState = $transition->getTargetState();
                $this->addState($targetState);
            }
        }
    }

    /**
     * @param SetupHelper $setupHelper
     */
    protected function initProcess(SetupHelper $setupHelper)

The parameter $setupHelper is not used and could be removed.

    {
        // overwrite to use SetupHelper
    }

    /**
     */
    protected function createCollection()
    {
        $this->states = new StateCollection();
        $this->addState($this->initialState);
    }

    /**
     * @see MetaborStd\Statemachine.ProcessInterface::getInitialState()
     */
    public function getInitialState()
    {
        return $this->initialState;
    }

    /**
     * @see MetaborStd\Statemachine.ProcessInterface::getStates()
     */
    public function getStates()
    {
        return $this->states->getStates();
    }

    /**
     * @param string $name
     */
    public function getState($name)
    {
        return $this->states->getState($name);
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public function hasState($name)
    {
        return $this->states->hasState($name);
    }

    /**
     * @return StateCollectionMerger
     */
    public function getStateCollectionMerger()
    {
        if (!$this->stateCollectionMerger) {
            $this->stateCollectionMerger = new StateCollectionMerger($this->states);
        }

        return $this->stateCollectionMerger;
    }

    /**
     * @see \MetaborStd\MergeableInterface::merge()
     */
    public function merge($source)
    {
        $merger = $this->getStateCollectionMerger();
        $merger->merge($source);
    }
}