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

Connector::cleanup() A
last analyzed 2019-06-19 10:10 UTC

↳ Parent: Connector

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
 * Managed instance creator
 * User: moyo
 * Date: 09/08/2017
 * Time: 5:43 PM
 */

namespace Carno\Pool;

use function Carno\Coroutine\async;
use Carno\Pool\Exception\InvalidConnectorException;
use Carno\Promise\Promise;
use Carno\Promise\Promised;
use Closure;
use Generator;

class Connector
{
    /**
     * @var Pool
     */
    private $pool = null;

    /**
     * @var Closure
     */
    private $dialer = null;

    /**
     * @var string
     */
    private $identify = null;

    /**
     * Connector constructor.
     * @param Pool $pool
     * @param Closure $dialer
     * @param string $identify
     */
    public function __construct(Pool $pool, Closure $dialer, string $identify)
    {
        $this->pool = $pool;
        $this->dialer = $dialer;
        $this->identify = $identify;
    }

    /**
     */
    public function cleanup() : void
    {
        $this->pool = null;
        $this->dialer = null;
    }

    /**
     * @return string
     */
    public function identify() : string
    {
        return $this->identify;
    }

    /**
     * @return Promised|Poolable
     */
    public function created() : Promised
    {
        $created = ($this->dialer)();

        if ($created instanceof Generator) {
            $created = async($created);
            goto PROMISED;
        }

        if ($created instanceof Poolable) {
            // currently usable instance
            $created->pool($this->pool);
            return Promise::resolved($created);
        }

        PROMISED:

        if ($created instanceof Promised) {
            // deferred create instance
            $created->then(function (Poolable $created) {
                $created->pool($this->pool);
            });
            return $created;
        }

        throw new InvalidConnectorException($this->identify());
    }
}


1			<?php
2			/**
3			* Managed instance creator
4			* User: moyo
5			* Date: 09/08/2017
6			* Time: 5:43 PM
7			*/
8
9			namespace Carno\Pool;
10
11			use function Carno\Coroutine\async;
12			use Carno\Pool\Exception\InvalidConnectorException;
13			use Carno\Promise\Promise;
14			use Carno\Promise\Promised;
15			use Closure;
16			use Generator;
17
18			class Connector
19			{
20			/**
21			* @var Pool
22			*/
23			private $pool = null;
24
25			/**
26			* @var Closure
27			*/
28			private $dialer = null;
29
30			/**
31			* @var string
32			*/
33			private $identify = null;
34
35			/**
36			* Connector constructor.
37			* @param Pool $pool
38			* @param Closure $dialer
39			* @param string $identify
40			*/
41			public function __construct(Pool $pool, Closure $dialer, string $identify)
42			{
43			$this->pool = $pool;
44			$this->dialer = $dialer;
45			$this->identify = $identify;
46			}
47
48			/**
49			*/
50			public function cleanup() : void
51			{
52			$this->pool = null;
53			$this->dialer = null;
54			}
55
56			/**
57			* @return string
58			*/
59			public function identify() : string
60			{
61			return $this->identify;
62			}
63
64			/**
65			* @return Promised\|Poolable
66			*/
67			public function created() : Promised
68			{
69			$created = ($this->dialer)();
70
71			if ($created instanceof Generator) {
72			$created = async($created);
73			goto PROMISED;
74			}
75
76			if ($created instanceof Poolable) {
77			// currently usable instance
78			$created->pool($this->pool);
79			return Promise::resolved($created);
80			}
81
82			PROMISED:
83
84			if ($created instanceof Promised) {
85			// deferred create instance
86			$created->then(function (Poolable $created) {
87			$created->pool($this->pool);
88			});
89			return $created;
90			}
91
92			throw new InvalidConnectorException($this->identify());
93			}
94			}
95

carno-php / pool

Connector::cleanup() A last analyzed 2019-06-19 10:10 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Connector::cleanup() A
last analyzed 2019-06-19 10:10 UTC