Managed::scheduled() - Code Metrics - carno-php/pool - Measure and Improve Code Quality continuously with Scrutinizer

Managed::scheduled() A
last analyzed 2019-06-19 10:10 UTC

↳ Parent: Managed

Complexity

Conditions	3
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	4
nc	2
nop	0
dl	0
loc	7
rs	10
c	0
b	0
f	0

<?php
/**
 * Conn managed
 * User: moyo
 * Date: 09/08/2017
 * Time: 3:37 PM
 */

namespace Carno\Pool;

use Carno\Promise\Promise;
use Carno\Promise\Promised;

trait Managed
{
    /**
     * @var string
     */
    private $cid = 'c--';

    /**
     * @var Pool
     */
    private $pool = null;

    /**
     * @var Promised
     */
    private $closed = null;

    /**
     * @var Promised[]
     */
    private $schedules = [];

    /**
     * @see Poolable::cid
     * @param string $set
     * @return string
     */
    final public function cid(string $set = null) : string
    {
        return $set ? $this->cid = $set : $this->cid;
    }

    /**
     * @see Poolable::pool
     * @param Pool $pool
     */
    final public function pool(Pool $pool) : void
    {
        $this->pool = $pool;
    }

    /**
     * @see Poolable::closed
     * @return Promised
     */
    final public function closed() : Promised
    {
        if (isset($this->closed)) {
            return $this->closed;
        }

        ($this->closed = Promise::deferred())->then(function () {
            $this->destroy();
        }, function () {
            $this->destroy();
        });

        return $this->closed;
    }

    /**
     * @see Poolable::schedule
     * @param int $evk
     * @param Promised $future
     */
    final public function schedule(int $evk, Promised $future) : void
    {
        $this->schedules[$evk] = $future;
    }

    /**
     * @see Poolable::release
     */
    final public function release() : void
    {
        if (isset($this->pool)) {
            $this->scheduled() || $this->pool->recycle($this);
        }
    }

    /**
     * @see Poolable::destroy
     */
    final public function destroy() : void
    {
        if (isset($this->pool)) {
            $pool = $this->pool;
            unset($this->pool);
            $this->scheduled();
            $pool->release($this);
        }
    }

    /**
     * @return bool
     */
    final private function scheduled() : bool
    {
        if (($w = $this->schedules[Poolable::RELEASED] ?? null) && $w->pended()) {
            $w->resolve($this);
            return true;
        }
        return false;
    }
}


1			<?php
2			/**
3			* Conn managed
4			* User: moyo
5			* Date: 09/08/2017
6			* Time: 3:37 PM
7			*/
8
9			namespace Carno\Pool;
10
11			use Carno\Promise\Promise;
12			use Carno\Promise\Promised;
13
14			trait Managed
15			{
16			/**
17			* @var string
18			*/
19			private $cid = 'c--';
20
21			/**
22			* @var Pool
23			*/
24			private $pool = null;
25
26			/**
27			* @var Promised
28			*/
29			private $closed = null;
30
31			/**
32			* @var Promised[]
33			*/
34			private $schedules = [];
35
36			/**
37			* @see Poolable::cid
38			* @param string $set
39			* @return string
40			*/
41			final public function cid(string $set = null) : string
42			{
43			return $set ? $this->cid = $set : $this->cid;
44			}
45
46			/**
47			* @see Poolable::pool
48			* @param Pool $pool
49			*/
50			final public function pool(Pool $pool) : void
51			{
52			$this->pool = $pool;
53			}
54
55			/**
56			* @see Poolable::closed
57			* @return Promised
58			*/
59			final public function closed() : Promised
60			{
61			if (isset($this->closed)) {
62			return $this->closed;
63			}
64
65			($this->closed = Promise::deferred())->then(function () {
66			$this->destroy();
67			}, function () {
68			$this->destroy();
69			});
70
71			return $this->closed;
72			}
73
74			/**
75			* @see Poolable::schedule
76			* @param int $evk
77			* @param Promised $future
78			*/
79			final public function schedule(int $evk, Promised $future) : void
80			{
81			$this->schedules[$evk] = $future;
82			}
83
84			/**
85			* @see Poolable::release
86			*/
87			final public function release() : void
88			{
89			if (isset($this->pool)) {
90			$this->scheduled() \|\| $this->pool->recycle($this);
91			}
92			}
93
94			/**
95			* @see Poolable::destroy
96			*/
97			final public function destroy() : void
98			{
99			if (isset($this->pool)) {
100			$pool = $this->pool;
101			unset($this->pool);
102			$this->scheduled();
103			$pool->release($this);
104			}
105			}
106
107			/**
108			* @return bool
109			*/
110			final private function scheduled() : bool
111			{
112			if (($w = $this->schedules[Poolable::RELEASED] ?? null) && $w->pended()) {
113			$w->resolve($this);
114			return true;
115			}
116			return false;
117			}
118			}
119

carno-php / pool

Managed::scheduled() A last analyzed 2019-06-19 10:10 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Managed::scheduled() A
last analyzed 2019-06-19 10:10 UTC