FlowMap::duration() - Code Metrics - Inspection of "increment ref" - fab2s/NodalFlow - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 973769...9ec99d )

by Fabrice

created 2017-11-11 07:28 UTC

FlowMap::duration() A

↳ Parent: FlowMap

Complexity

Conditions	4
Paths	3

Size

Total Lines	20
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
rs	9.2
c	0
b	0
f	0
cc	4
eloc	12
nc	3
nop	1

<?php

/*
 * This file is part of NodalFlow.
 *     (c) Fabrice de Stefanis / https://github.com/fab2s/NodalFlow
 * This source file is licensed under the MIT license which you will
 * find in the LICENSE file or at https://opensource.org/licenses/MIT
 */

namespace fab2s\NodalFlow\Flows;

use fab2s\NodalFlow\NodalFlowException;
use fab2s\NodalFlow\Nodes\AggregateNodeInterface;
use fab2s\NodalFlow\Nodes\BranchNodeInterface;
use fab2s\NodalFlow\Nodes\NodeInterface;

/**
 * class FlowMap
 */
class FlowMap implements FlowMapInterface
{
    /**
     * Flow map
     *
     * @var array
     */
    protected $nodeMap = [];

    /**
     * @var array
     */
    protected $reverseMap = [];

    /**
     * The default Node Map values
     *
     * @var array
     */
    protected $nodeMapDefault = [
        'class'           => null,
        'flowId'          => null,
        'hash'            => null,
        'index'           => null,
        'isATraversable'  => null,
        'isAReturningVal' => null,
        'isAFlow'         => null,
        'num_exec'        => 0,
        'num_iterate'     => 0,
        'num_break'       => 0,
        'num_continue'    => 0,
    ];

    /**
     * The default Node stats values
     *
     * @var array
     */
    protected $incrementStatsDefault = [
        'num_exec'     => 0,
        'num_iterate'  => 0,
        'num_break'    => 0,
        'num_continue' => 0,
    ];

    /**
     * The Flow stats default values
     *
     * @var array
     */
    protected $flowStatsDefault = [
        'class'    => null,
        'id'       => null,
        'start'    => null,
        'end'      => null,
        'elapsed'  => null,
        'duration' => null,
        'mib'      => null,
    ];

    /**
     * @var array
     */
    protected $defaultFlowStats;

    /**
     * @var array
     */
    protected $flowStats;

    /**
     * @var bool
     */
    protected $resetOnRestart = false;

    /**
     * @var FlowInterface
     */
    protected $flow;

    /**
     * @var bool
     */
    protected $hasRun = false;

    /**
     * Instantiate a Flow Status
     *
     * @param FlowInterface $flow
     *
     * @internal param string $status The flow status
     */
    public function __construct(FlowInterface $flow)
    {
        $this->flow             = $flow;
        $this->defaultFlowStats = array_replace($this->flowStatsDefault, $this->incrementStatsDefault, [
            'class' => get_class($this->flow),
            'id'    => $this->flow->getId(),
        ]);
        $this->flowStats        = $this->defaultFlowStats;
    }

    /**
     * Set additional increment keys, use :
     *      'keyName' => int
     * to add keyName as increment, starting at int
     * or :
     *      'keyName' => 'existingIncrement'
     * to assign keyName as a reference to existingIncrement
     *
     * @param array $flowIncrements
     *
     * @throws NodalFlowException
     *
     * @return $this
     */
    public function setFlowIncrement(array $flowIncrements)
    {
        if ($this->hasRun) {
            throw new NodalFlowException('Cannot set custom increment after Flow started');
        }

        foreach ($flowIncrements as $incrementKey => $target) {
            if (is_string($target)) {
                if (!isset($this->flowStats[$target])) {
                    throw new NodalFlowException('Cannot set reference on unset target');
                }

                $this->flowStats[$incrementKey] = &$this->flowStats[$target];
                continue;
            }

            $this->defaultFlowStats[$incrementKey] = $target;
            $this->flowStats[$incrementKey]        = $target;
        }

        return $this;
    }

    /**
     * @param NodeInterface $node
     * @param int           $index
     *
     * @throws NodalFlowException
     */
    public function register(NodeInterface $node, $index)
    {
        $this->enforceUniqueness($node);
        $nodeHash                      = $node->getNodeHash();
        $this->nodeMap[$nodeHash]      = array_replace($this->nodeMapDefault, [
            'class'           => get_class($node),
            'flowId'          => $node->getCarrier()->getId(),
            'hash'            => $nodeHash,
            'index'           => $index,
            'isATraversable'  => $node->isTraversable(),
            'isAReturningVal' => $node->isReturningVal(),
            'isAFlow'         => $node->isFlow(),
        ]);

        if (isset($this->reverseMap[$index])) {
            // replacing a note, maintain nodeMap accordingly
            unset($this->nodeMap[$this->reverseMap[$index]]);
        }

        $this->reverseMap[$index] = $nodeHash;
    }

    /**
     * Triggered right before the flow starts
     *
     * @return $this
     */
    public function flowStart()
    {
        $this->flowStats['start'] = microtime(true);
        $this->hasRun             = true;

        return $this;
    }

    /**
     * Triggered right after the flow stops
     *
     * @return $this
     */
    public function flowEnd()
    {
        $this->flowStats['end']     = microtime(true);
        $this->flowStats['mib']     = memory_get_peak_usage(true) / 1048576;
        $this->flowStats['elapsed'] = $this->flowStats['end'] - $this->flowStats['start'];

        $this->flowStats = array_replace($this->flowStats, $this->duration($this->flowStats['elapsed']));

        return $this;
    }

    /**
     * Get/Generate Node Map
     *
     * @return array
     */
    public function getNodeMap()
    {
        foreach ($this->flow->getNodes() as $node) {
            if ($node instanceof BranchNodeInterface) {
                $this->nodeMap[$node->getNodeHash()]['nodes'] = $node->getPayload()->getNodeMap();
                continue;
            }

            if ($node instanceof AggregateNodeInterface) {
                $flowId = $node->getCarrier()->getId();
                foreach ($node->getNodeCollection() as $aggregatedNode) {
                    $this->nodeMap[$node->getNodeHash()]['nodes'][$aggregatedNode->getNodeHash()] = array_replace($this->nodeMapDefault, [
                        'class'  => get_class($aggregatedNode),
                        'flowId' => $flowId,
                        'hash'   => $aggregatedNode->getNodeHash(),
                    ]);
                }
                continue;
            }
        }

        return $this->nodeMap;
    }

    /**
     * Get the latest Node stats
     *
     * @return array
     */
    public function getStats()
    {
        $result = array_intersect_key($this->flowStats, $this->defaultFlowStats);
        foreach ($this->flow->getNodes() as $node) {
            if ($node instanceof BranchNodeInterface) {
                $result['branches'][$node->getPayload()->getId()] = $node->getPayload()->getStats();
            }
        }

        return $result;
    }

    /**
     * @param string $nodeHash
     * @param array  $incrementAliases
     *
     * @throws NodalFlowException
     *
     * @return $this
     */
    public function setIncrementAlias($nodeHash, array $incrementAliases = [])
    {
        foreach ($incrementAliases as $aliasKey => $incKey) {
            if (!isset($this->incrementStatsDefault[$incKey])) {
                throw new NodalFlowException('Tried to set an increment alias to an un-registered increment', 1, null, [
                    'aliasKey'     => $aliasKey,
                    'incrementKey' => $incKey,
                ]);
            }

            $this->nodeMap[$nodeHash][$aliasKey] = &$this->nodeMap[$nodeHash][$incKey];
        }

        return $this;
    }

    /**
     * @param string $nodeHash
     * @param string $key
     *
     * @return $this
     */
    public function increment($nodeHash, $key)
    {
        ++$this->nodeMap[$nodeHash][$key];

        return $this;
    }

    /**
     * @param string $key
     *
     * @return $this
     */
    public function incrementFlow($key)
    {
        ++$this->flowStats[$key];

        return $this;
    }

    /**
     * Resets Nodes stats, can be used prior to Flow's re-exec
     *
     * @return $this
     */
    public function resetNodeStats()
    {
        foreach ($this->nodeMap as &$nodeStat) {
            $nodeStat = array_replace($nodeStat, $this->incrementStatsDefault);
        }

        return $this;
    }

    /**
     * Computes a human readable duration string from floating seconds
     *
     * @param float $seconds
     *
     * @return array<string,integer|string>
     */
    public function duration($seconds)
    {
        $result = [
            'hour'     => (int) floor($seconds / 3600),
            'min'      => (int) floor(($seconds / 60) % 60),
            'sec'      => $seconds % 60,
            'ms'       => (int) round(\fmod($seconds, 1) * 1000),
        ];

        $duration = '';
        foreach ($result as $unit => $value) {
            if (!empty($value) || $unit === 'ms') {
                $duration .= $value . "$unit ";
            }
        }

        $result['duration'] = trim($duration);

        return $result;
    }

    /**
     * @param NodeInterface $node
     *
     * @throws NodalFlowException
     *
     * @return $this
     */
    protected function enforceUniqueness(NodeInterface $node)
    {
        if (isset($this->nodeMap[$node->getNodeHash()])) {
            throw new NodalFlowException('Cannot reuse Node instances within a Flow', 1, null, [
                'duplicate_node' => get_class($node),
                'hash'           => $node->getNodeHash(),
            ]);
        }

        return $this;
    }
}


1			<?php
2
3			/*
4			* This file is part of NodalFlow.
5			* (c) Fabrice de Stefanis / https://github.com/fab2s/NodalFlow
6			* This source file is licensed under the MIT license which you will
7			* find in the LICENSE file or at https://opensource.org/licenses/MIT
8			*/
9
10			namespace fab2s\NodalFlow\Flows;
11
12			use fab2s\NodalFlow\NodalFlowException;
13			use fab2s\NodalFlow\Nodes\AggregateNodeInterface;
14			use fab2s\NodalFlow\Nodes\BranchNodeInterface;
15			use fab2s\NodalFlow\Nodes\NodeInterface;
16
17			/**
18			* class FlowMap
19			*/
20			class FlowMap implements FlowMapInterface
21			{
22			/**
23			* Flow map
24			*
25			* @var array
26			*/
27			protected $nodeMap = [];
28
29			/**
30			* @var array
31			*/
32			protected $reverseMap = [];
33
34			/**
35			* The default Node Map values
36			*
37			* @var array
38			*/
39			protected $nodeMapDefault = [
40			'class' => null,
41			'flowId' => null,
42			'hash' => null,
43			'index' => null,
44			'isATraversable' => null,
45			'isAReturningVal' => null,
46			'isAFlow' => null,
47			'num_exec' => 0,
48			'num_iterate' => 0,
49			'num_break' => 0,
50			'num_continue' => 0,
51			];
52
53			/**
54			* The default Node stats values
55			*
56			* @var array
57			*/
58			protected $incrementStatsDefault = [
59			'num_exec' => 0,
60			'num_iterate' => 0,
61			'num_break' => 0,
62			'num_continue' => 0,
63			];
64
65			/**
66			* The Flow stats default values
67			*
68			* @var array
69			*/
70			protected $flowStatsDefault = [
71			'class' => null,
72			'id' => null,
73			'start' => null,
74			'end' => null,
75			'elapsed' => null,
76			'duration' => null,
77			'mib' => null,
78			];
79
80			/**
81			* @var array
82			*/
83			protected $defaultFlowStats;
84
85			/**
86			* @var array
87			*/
88			protected $flowStats;
89
90			/**
91			* @var bool
92			*/
93			protected $resetOnRestart = false;
94
95			/**
96			* @var FlowInterface
97			*/
98			protected $flow;
99
100			/**
101			* @var bool
102			*/
103			protected $hasRun = false;
104
105			/**
106			* Instantiate a Flow Status
107			*
108			* @param FlowInterface $flow
109			*
110			* @internal param string $status The flow status
111			*/
112			public function __construct(FlowInterface $flow)
113			{
114			$this->flow = $flow;
115			$this->defaultFlowStats = array_replace($this->flowStatsDefault, $this->incrementStatsDefault, [
116			'class' => get_class($this->flow),
117			'id' => $this->flow->getId(),
118			]);
119			$this->flowStats = $this->defaultFlowStats;
120			}
121
122			/**
123			* Set additional increment keys, use :
124			* 'keyName' => int
125			* to add keyName as increment, starting at int
126			* or :
127			* 'keyName' => 'existingIncrement'
128			* to assign keyName as a reference to existingIncrement
129			*
130			* @param array $flowIncrements
131			*
132			* @throws NodalFlowException
133			*
134			* @return $this
135			*/
136			public function setFlowIncrement(array $flowIncrements)
137			{
138			if ($this->hasRun) {
139			throw new NodalFlowException('Cannot set custom increment after Flow started');
140			}
141
142			foreach ($flowIncrements as $incrementKey => $target) {
143			if (is_string($target)) {
144			if (!isset($this->flowStats[$target])) {
145			throw new NodalFlowException('Cannot set reference on unset target');
146			}
147
148			$this->flowStats[$incrementKey] = &$this->flowStats[$target];
149			continue;
150			}
151
152			$this->defaultFlowStats[$incrementKey] = $target;
153			$this->flowStats[$incrementKey] = $target;
154			}
155
156			return $this;
157			}
158
159			/**
160			* @param NodeInterface $node
161			* @param int $index
162			*
163			* @throws NodalFlowException
164			*/
165			public function register(NodeInterface $node, $index)
166			{
167			$this->enforceUniqueness($node);
168			$nodeHash = $node->getNodeHash();
169			$this->nodeMap[$nodeHash] = array_replace($this->nodeMapDefault, [
170			'class' => get_class($node),
171			'flowId' => $node->getCarrier()->getId(),
172			'hash' => $nodeHash,
173			'index' => $index,
174			'isATraversable' => $node->isTraversable(),
175			'isAReturningVal' => $node->isReturningVal(),
176			'isAFlow' => $node->isFlow(),
177			]);
178
179			if (isset($this->reverseMap[$index])) {
180			// replacing a note, maintain nodeMap accordingly
181			unset($this->nodeMap[$this->reverseMap[$index]]);
182			}
183
184			$this->reverseMap[$index] = $nodeHash;
185			}
186
187			/**
188			* Triggered right before the flow starts
189			*
190			* @return $this
191			*/
192			public function flowStart()
193			{
194			$this->flowStats['start'] = microtime(true);
195			$this->hasRun = true;
196
197			return $this;
198			}
199
200			/**
201			* Triggered right after the flow stops
202			*
203			* @return $this
204			*/
205			public function flowEnd()
206			{
207			$this->flowStats['end'] = microtime(true);
208			$this->flowStats['mib'] = memory_get_peak_usage(true) / 1048576;
209			$this->flowStats['elapsed'] = $this->flowStats['end'] - $this->flowStats['start'];
210
211			$this->flowStats = array_replace($this->flowStats, $this->duration($this->flowStats['elapsed']));
212
213			return $this;
214			}
215
216			/**
217			* Get/Generate Node Map
218			*
219			* @return array
220			*/
221			public function getNodeMap()
222			{
223			foreach ($this->flow->getNodes() as $node) {
224			if ($node instanceof BranchNodeInterface) {
225			$this->nodeMap[$node->getNodeHash()]['nodes'] = $node->getPayload()->getNodeMap();
226			continue;
227			}
228
229			if ($node instanceof AggregateNodeInterface) {
230			$flowId = $node->getCarrier()->getId();
231			foreach ($node->getNodeCollection() as $aggregatedNode) {
232			$this->nodeMap[$node->getNodeHash()]['nodes'][$aggregatedNode->getNodeHash()] = array_replace($this->nodeMapDefault, [
233			'class' => get_class($aggregatedNode),
234			'flowId' => $flowId,
235			'hash' => $aggregatedNode->getNodeHash(),
236			]);
237			}
238			continue;
239			}
240			}
241
242			return $this->nodeMap;
243			}
244
245			/**
246			* Get the latest Node stats
247			*
248			* @return array
249			*/
250			public function getStats()
251			{
252			$result = array_intersect_key($this->flowStats, $this->defaultFlowStats);
253			foreach ($this->flow->getNodes() as $node) {
254			if ($node instanceof BranchNodeInterface) {
255			$result['branches'][$node->getPayload()->getId()] = $node->getPayload()->getStats();
256			}
257			}
258
259			return $result;
260			}
261
262			/**
263			* @param string $nodeHash
264			* @param array $incrementAliases
265			*
266			* @throws NodalFlowException
267			*
268			* @return $this
269			*/
270			public function setIncrementAlias($nodeHash, array $incrementAliases = [])
271			{
272			foreach ($incrementAliases as $aliasKey => $incKey) {
273			if (!isset($this->incrementStatsDefault[$incKey])) {
274			throw new NodalFlowException('Tried to set an increment alias to an un-registered increment', 1, null, [
275			'aliasKey' => $aliasKey,
276			'incrementKey' => $incKey,
277			]);
278			}
279
280			$this->nodeMap[$nodeHash][$aliasKey] = &$this->nodeMap[$nodeHash][$incKey];
281			}
282
283			return $this;
284			}
285
286			/**
287			* @param string $nodeHash
288			* @param string $key
289			*
290			* @return $this
291			*/
292			public function increment($nodeHash, $key)
293			{
294			++$this->nodeMap[$nodeHash][$key];
295
296			return $this;
297			}
298
299			/**
300			* @param string $key
301			*
302			* @return $this
303			*/
304			public function incrementFlow($key)
305			{
306			++$this->flowStats[$key];
307
308			return $this;
309			}
310
311			/**
312			* Resets Nodes stats, can be used prior to Flow's re-exec
313			*
314			* @return $this
315			*/
316			public function resetNodeStats()
317			{
318			foreach ($this->nodeMap as &$nodeStat) {
319			$nodeStat = array_replace($nodeStat, $this->incrementStatsDefault);
320			}
321
322			return $this;
323			}
324
325			/**
326			* Computes a human readable duration string from floating seconds
327			*
328			* @param float $seconds
329			*
330			* @return array<string,integer\|string>
331			*/
332			public function duration($seconds)
333			{
334			$result = [
335			'hour' => (int) floor($seconds / 3600),
336			'min' => (int) floor(($seconds / 60) % 60),
337			'sec' => $seconds % 60,
338			'ms' => (int) round(\fmod($seconds, 1) * 1000),
339			];
340
341			$duration = '';
342			foreach ($result as $unit => $value) {
343			if (!empty($value) \|\| $unit === 'ms') {
344			$duration .= $value . "$unit ";
345			}
346			}
347
348			$result['duration'] = trim($duration);
349
350			return $result;
351			}
352
353			/**
354			* @param NodeInterface $node
355			*
356			* @throws NodalFlowException
357			*
358			* @return $this
359			*/
360			protected function enforceUniqueness(NodeInterface $node)
361			{
362			if (isset($this->nodeMap[$node->getNodeHash()])) {
363			throw new NodalFlowException('Cannot reuse Node instances within a Flow', 1, null, [
364			'duplicate_node' => get_class($node),
365			'hash' => $node->getNodeHash(),
366			]);
367			}
368
369			return $this;
370			}
371			}
372

fab2s / NodalFlow

Push — master ( 973769...9ec99d )

FlowMap::duration() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like