Statemachine::isAutoreleaseLock() - Code Metrics - Inspection of "update composer" - Metabor/Statemachine - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (c08b38)

by Oliver

created 2019-06-12 16:38 UTC

Statemachine::isAutoreleaseLock() A

↳ Parent: Statemachine

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	4
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	2

<?php

namespace Metabor\Statemachine;

use Metabor\Callback\Callback;
use Metabor\Event\Dispatcher;
use Metabor\Observer\Subject;
use Metabor\Semaphore\NullMutex;
use Metabor\Statemachine\Exception\LockCanNotBeAcquiredException;
use Metabor\Statemachine\Exception\WrongEventForStateException;
use Metabor\Statemachine\Factory\TransitionSelector\OneOrNoneActiveTransition;
use Metabor\Statemachine\Transition\ActiveTransitionFilter;
use MetaborStd\Event\DispatcherInterface;
use MetaborStd\Event\EventInterface;
use MetaborStd\NamedInterface;
use MetaborStd\Semaphore\MutexInterface;
use MetaborStd\Statemachine\Factory\TransitionSelectorInterface;
use MetaborStd\Statemachine\ProcessInterface;
use MetaborStd\Statemachine\StateInterface;
use MetaborStd\Statemachine\StatemachineInterface;
use MetaborStd\Statemachine\TransitionInterface;

/**
 * @author Oliver Tischlinger
 */
class Statemachine extends Subject implements StatemachineInterface
{
    /**
     * @var object
     */
    private $subject;

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

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

    /**
     * @var DispatcherInterface
     */
    private $dispatcher;

    /**
     * @var EventInterface
     */
    private $currentEvent;

    /**
     * @var \ArrayAccess
     */
    private $currentContext;

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

    /**
     * @var TransitionInterface
     */
    private $selectedTransition;

    /**
     * @var ProcessInterface
     */
    private $process;

    /**
     * @var MutexInterface
     */
    private $mutex;

    /**
     * @var bool
     */
    private $autoreleaseLock = true;

    /**
     * @param object                      $subject
     * @param ProcessInterface            $process
     * @param string                      $stateName
     * @param TransitionSelectorInterface $transitonSelector
     * @param MutexInterface              $mutex
     */
    public function __construct(
        $subject,
        ProcessInterface $process,
        $stateName = null,
        TransitionSelectorInterface $transitonSelector = null,
        MutexInterface $mutex = null
    ) {
        parent::__construct();
        $this->subject = $subject;
        if ($stateName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $this->currentState = $process->getState($stateName);
        } else {
            $this->currentState = $process->getInitialState();
        }
        if ($transitonSelector) {
            $this->transitonSelector = $transitonSelector;
        } else {
            $this->transitonSelector = new OneOrNoneActiveTransition();
        }
        $this->process = $process;
        if ($mutex) {
            $this->mutex = $mutex;
        } else {
            $this->mutex = new NullMutex();
        }
    }

    /**
     * @return ProcessInterface
     */
    public function getProcess()
    {
        return $this->process;
    }

    /**
     * @see MetaborStd\Statemachine.StatemachineInterface::getCurrentState()
     */
    public function getCurrentState()
    {
        return $this->currentState;
    }

    /**
     * @return StateInterface
     */
    public function getLastState()
    {
        return $this->lastState;
    }

    /**
     * @param \ArrayAccess   $context
     * @param EventInterface $event
     */
    protected function doCheckTransitions(\ArrayAccess $context, EventInterface $event = null)
    {
        try {
            $transitions = $this->currentState->getTransitions();
            $activeTransitions = new ActiveTransitionFilter($transitions, $this->getSubject(), $context, $event);
            $this->selectedTransition = $this->transitonSelector->selectTransition($activeTransitions);
            if ($this->selectedTransition) {
                $targetState = $this->selectedTransition->getTargetState();
                if ($this->currentState != $targetState) {
                    $this->lastState = $this->currentState;
                    $this->currentState = $targetState;
                    $this->currentContext = $context;
                    $this->currentEvent = $event;
                    $this->notify();
                    $this->currentContext = null;
                    $this->currentEvent = null;
                    $this->selectedTransition = null;
                    $this->lastState = null;
                }
                $this->doCheckTransitions($context);
            }
        } catch (\Exception $exception) {
            $message = 'Exception was thrown when doing a transition from current state "' . $this->currentState->getName() . '"';
            if ($this->currentEvent instanceof NamedInterface) {
                $message .= ' with event "' . $this->currentEvent->getName() . '"';
            }
            if ($this->subject instanceof NamedInterface) {
                $message .= ' for "' . $this->subject->getName() . '"';
            }
            throw new \RuntimeException($message, 0, $exception);
        }
    }

    /**
     * @return \MetaborStd\Statemachine\TransitionInterface
     */
    public function getSelectedTransition()
    {
        return $this->selectedTransition;
    }

    /**
     * is called after dispatcher was executed.
     */
    public function onDispatcherReady()
    {
        if ($this->dispatcher && $this->dispatcher->isReady()) {
            $context = $this->currentContext;
            $event = $this->currentEvent;
            $this->dispatcher = null;
            $this->currentContext = null;
            $this->currentEvent = null;
            $this->doCheckTransitions($context, $event);
            if ($this->autoreleaseLock) {
                $this->mutex->releaseLock();
            }
        }
    }

    /**
     * @param DispatcherInterface $dispatcher
     * @param string              $name
     * @param \ArrayAccess        $context
     *
     * @throws \RuntimeException
     */
    public function dispatchEvent(DispatcherInterface $dispatcher, $name, \ArrayAccess $context = null)
    {
        if ($this->dispatcher) {
            throw new \RuntimeException('Event dispatching is still running!');
        } else {
            if ($this->currentState->hasEvent($name)) {
                $this->acquireLockOrThrowException();
                $this->dispatcher = $dispatcher;

                if ($context) {
                    $this->currentContext = $context;
                } else {
                    $this->currentContext = new \ArrayIterator(array());
                }
                $this->currentEvent = $this->currentState->getEvent($name);

                $dispatcher->dispatch($this->currentEvent, array($this->subject, $this->currentContext), new Callback(array($this, 'onDispatcherReady')));
            } else {
                throw new WrongEventForStateException($this->currentState->getName(), $name);
            }
        }
    }

    /**
     * @param string $name
     * @param \ArrayAccess|null $context
     */
    public function triggerEvent($name, \ArrayAccess $context = null)
    {
        $dispatcher = new Dispatcher();
        $this->dispatchEvent($dispatcher, $name, $context);
        $dispatcher();
    }

    /**
     * @param \ArrayAccess|null $context
     */
    public function checkTransitions(\ArrayAccess $context = null)
    {
        $this->acquireLockOrThrowException();
        if (!$context) {
            $context = new \ArrayIterator(array());
        }
        $this->doCheckTransitions($context);
        if ($this->autoreleaseLock) {
            $this->mutex->releaseLock();
        }
    }

    /**
     * @see \MetaborStd\Statemachine\StatemachineInterface::getSubject()
     */
    public function getSubject()
    {
        return $this->subject;
    }

    /**
     * @return \ArrayAccess
     */
    public function getCurrentContext()
    {
        return $this->currentContext;
    }

    /**
     * @throws LockCanNotBeAcquiredException
     */
    protected function acquireLockOrThrowException()
    {
        if (!$this->acquireLock()) {
            throw new LockCanNotBeAcquiredException('Lock can not be acquired!');
        }
    }

    /**
     * @return bool
     */
    public function isAutoreleaseLock()
    {
        return $this->autoreleaseLock;
    }

    /**
     * @param bool $autoreleaseLock
     */
    public function setAutoreleaseLock($autoreleaseLock)
    {
        $this->autoreleaseLock = $autoreleaseLock;
    }

    /**
     * Use this function if you want to aquire lock before calling triggerEvent or checkTransitions.
     * Lock is aquired automatically when calling dispatchEvent or checkTransitions.
     *
     * @return bool
     */
    public function acquireLock()
    {
        if ($this->mutex->isAcquired()) {
            return true;
        } else {
            return $this->mutex->acquireLock();
        }
    }
}


1			<?php
2
3			namespace Metabor\Statemachine;
4
5			use Metabor\Callback\Callback;
6			use Metabor\Event\Dispatcher;
7			use Metabor\Observer\Subject;
8			use Metabor\Semaphore\NullMutex;
9			use Metabor\Statemachine\Exception\LockCanNotBeAcquiredException;
10			use Metabor\Statemachine\Exception\WrongEventForStateException;
11			use Metabor\Statemachine\Factory\TransitionSelector\OneOrNoneActiveTransition;
12			use Metabor\Statemachine\Transition\ActiveTransitionFilter;
13			use MetaborStd\Event\DispatcherInterface;
14			use MetaborStd\Event\EventInterface;
15			use MetaborStd\NamedInterface;
16			use MetaborStd\Semaphore\MutexInterface;
17			use MetaborStd\Statemachine\Factory\TransitionSelectorInterface;
18			use MetaborStd\Statemachine\ProcessInterface;
19			use MetaborStd\Statemachine\StateInterface;
20			use MetaborStd\Statemachine\StatemachineInterface;
21			use MetaborStd\Statemachine\TransitionInterface;
22
23			/**
24			* @author Oliver Tischlinger
25			*/
26			class Statemachine extends Subject implements StatemachineInterface
27			{
28			/**
29			* @var object
30			*/
31			private $subject;
32
33			/**
34			* @var StateInterface
35			*/
36			private $currentState;
37
38			/**
39			* @var StateInterface
40			*/
41			private $lastState;
42
43			/**
44			* @var DispatcherInterface
45			*/
46			private $dispatcher;
47
48			/**
49			* @var EventInterface
50			*/
51			private $currentEvent;
52
53			/**
54			* @var \ArrayAccess
55			*/
56			private $currentContext;
57
58			/**
59			* @var TransitionSelectorInterface
60			*/
61			private $transitonSelector;
62
63			/**
64			* @var TransitionInterface
65			*/
66			private $selectedTransition;
67
68			/**
69			* @var ProcessInterface
70			*/
71			private $process;
72
73			/**
74			* @var MutexInterface
75			*/
76			private $mutex;
77
78			/**
79			* @var bool
80			*/
81			private $autoreleaseLock = true;
82
83			/**
84			* @param object $subject
85			* @param ProcessInterface $process
86			* @param string $stateName
87			* @param TransitionSelectorInterface $transitonSelector
88			* @param MutexInterface $mutex
89			*/
90			public function __construct(
91			$subject,
92			ProcessInterface $process,
93			$stateName = null,
94			TransitionSelectorInterface $transitonSelector = null,
95			MutexInterface $mutex = null
96			) {
97			parent::__construct();
98			$this->subject = $subject;
99			if ($stateName) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-20 21:27 UTC by Report Bug Copy Issue Report The expression `$stateName` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
100			$this->currentState = $process->getState($stateName);
101			} else {
102			$this->currentState = $process->getInitialState();
103			}
104			if ($transitonSelector) {
105			$this->transitonSelector = $transitonSelector;
106			} else {
107			$this->transitonSelector = new OneOrNoneActiveTransition();
108			}
109			$this->process = $process;
110			if ($mutex) {
111			$this->mutex = $mutex;
112			} else {
113			$this->mutex = new NullMutex();
114			}
115			}
116
117			/**
118			* @return ProcessInterface
119			*/
120			public function getProcess()
121			{
122			return $this->process;
123			}
124
125			/**
126			* @see MetaborStd\Statemachine.StatemachineInterface::getCurrentState()
127			*/
128			public function getCurrentState()
129			{
130			return $this->currentState;
131			}
132
133			/**
134			* @return StateInterface
135			*/
136			public function getLastState()
137			{
138			return $this->lastState;
139			}
140
141			/**
142			* @param \ArrayAccess $context
143			* @param EventInterface $event
144			*/
145			protected function doCheckTransitions(\ArrayAccess $context, EventInterface $event = null)
146			{
147			try {
148			$transitions = $this->currentState->getTransitions();
149			$activeTransitions = new ActiveTransitionFilter($transitions, $this->getSubject(), $context, $event);
150			$this->selectedTransition = $this->transitonSelector->selectTransition($activeTransitions);
151			if ($this->selectedTransition) {
152			$targetState = $this->selectedTransition->getTargetState();
153			if ($this->currentState != $targetState) {
154			$this->lastState = $this->currentState;
155			$this->currentState = $targetState;
156			$this->currentContext = $context;
157			$this->currentEvent = $event;
158			$this->notify();
159			$this->currentContext = null;
160			$this->currentEvent = null;
161			$this->selectedTransition = null;
162			$this->lastState = null;
163			}
164			$this->doCheckTransitions($context);
165			}
166			} catch (\Exception $exception) {
167			$message = 'Exception was thrown when doing a transition from current state "' . $this->currentState->getName() . '"';
168			if ($this->currentEvent instanceof NamedInterface) {
169			$message .= ' with event "' . $this->currentEvent->getName() . '"';
170			}
171			if ($this->subject instanceof NamedInterface) {
172			$message .= ' for "' . $this->subject->getName() . '"';
173			}
174			throw new \RuntimeException($message, 0, $exception);
175			}
176			}
177
178			/**
179			* @return \MetaborStd\Statemachine\TransitionInterface
180			*/
181			public function getSelectedTransition()
182			{
183			return $this->selectedTransition;
184			}
185
186			/**
187			* is called after dispatcher was executed.
188			*/
189			public function onDispatcherReady()
190			{
191			if ($this->dispatcher && $this->dispatcher->isReady()) {
192			$context = $this->currentContext;
193			$event = $this->currentEvent;
194			$this->dispatcher = null;
195			$this->currentContext = null;
196			$this->currentEvent = null;
197			$this->doCheckTransitions($context, $event);
198			if ($this->autoreleaseLock) {
199			$this->mutex->releaseLock();
200			}
201			}
202			}
203
204			/**
205			* @param DispatcherInterface $dispatcher
206			* @param string $name
207			* @param \ArrayAccess $context
208			*
209			* @throws \RuntimeException
210			*/
211			public function dispatchEvent(DispatcherInterface $dispatcher, $name, \ArrayAccess $context = null)
212			{
213			if ($this->dispatcher) {
214			throw new \RuntimeException('Event dispatching is still running!');
215			} else {
216			if ($this->currentState->hasEvent($name)) {
217			$this->acquireLockOrThrowException();
218			$this->dispatcher = $dispatcher;
219
220			if ($context) {
221			$this->currentContext = $context;
222			} else {
223			$this->currentContext = new \ArrayIterator(array());
224			}
225			$this->currentEvent = $this->currentState->getEvent($name);
226
227			$dispatcher->dispatch($this->currentEvent, array($this->subject, $this->currentContext), new Callback(array($this, 'onDispatcherReady')));
228			} else {
229			throw new WrongEventForStateException($this->currentState->getName(), $name);
230			}
231			}
232			}
233
234			/**
235			* @param string $name
236			* @param \ArrayAccess\|null $context
237			*/
238			public function triggerEvent($name, \ArrayAccess $context = null)
239			{
240			$dispatcher = new Dispatcher();
241			$this->dispatchEvent($dispatcher, $name, $context);
242			$dispatcher();
243			}
244
245			/**
246			* @param \ArrayAccess\|null $context
247			*/
248			public function checkTransitions(\ArrayAccess $context = null)
249			{
250			$this->acquireLockOrThrowException();
251			if (!$context) {
252			$context = new \ArrayIterator(array());
253			}
254			$this->doCheckTransitions($context);
255			if ($this->autoreleaseLock) {
256			$this->mutex->releaseLock();
257			}
258			}
259
260			/**
261			* @see \MetaborStd\Statemachine\StatemachineInterface::getSubject()
262			*/
263			public function getSubject()
264			{
265			return $this->subject;
266			}
267
268			/**
269			* @return \ArrayAccess
270			*/
271			public function getCurrentContext()
272			{
273			return $this->currentContext;
274			}
275
276			/**
277			* @throws LockCanNotBeAcquiredException
278			*/
279			protected function acquireLockOrThrowException()
280			{
281			if (!$this->acquireLock()) {
282			throw new LockCanNotBeAcquiredException('Lock can not be acquired!');
283			}
284			}
285
286			/**
287			* @return bool
288			*/
289			public function isAutoreleaseLock()
290			{
291			return $this->autoreleaseLock;
292			}
293
294			/**
295			* @param bool $autoreleaseLock
296			*/
297			public function setAutoreleaseLock($autoreleaseLock)
298			{
299			$this->autoreleaseLock = $autoreleaseLock;
300			}
301
302			/**
303			* Use this function if you want to aquire lock before calling triggerEvent or checkTransitions.
304			* Lock is aquired automatically when calling dispatchEvent or checkTransitions.
305			*
306			* @return bool
307			*/
308			public function acquireLock()
309			{
310			if ($this->mutex->isAcquired()) {
311			return true;
312			} else {
313			return $this->mutex->acquireLock();
314			}
315			}
316			}
317

Metabor / Statemachine

Branch — master (c08b38)

Statemachine::isAutoreleaseLock() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like