RoundRobinQueue::__construct() - Code Metrics - bernardphp/bernard - Measure and Improve Code Quality continuously with Scrutinizer

RoundRobinQueue::__construct() A
last analyzed 2019-10-20 16:13 UTC

↳ Parent: RoundRobinQueue

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1.0028

Importance

Changes

Metric	Value
dl	0
loc	8
ccs	6
cts	7
cp	0.8571
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1.0028

<?php

namespace Bernard\Queue;

use Bernard\Envelope;
use Bernard\Queue;

class RoundRobinQueue implements Queue
{
    /**
     * @var Queue[]
     */
    protected $queues;

    /**
     * @var bool
     */
    protected $closed;

    /**
     * @var \SplObjectStorage
     */
    protected $envelopes;

    /**
     * @param Queue[] $queues
     */
    public function __construct(array $queues)
    {
        $this->validateQueues($queues);

        $this->queues = $this->indexQueues($queues);
        $this->envelopes = new \SplObjectStorage();
        $this->closed = false;
    }

    /**
     * {@inheritdoc}
     */
    public function enqueue(Envelope $envelope)
    {
        $this->verifyEnvelope($envelope);

        $this->queues[$envelope->getName()]->enqueue($envelope);
    }

    /**
     * {@inheritdoc}
     */
    public function dequeue()
    {
        $envelope = null;
        $checked = [];

        while (count($checked) < count($this->queues)) {
            $queue = current($this->queues);
            $envelope = $queue->dequeue();
            if (false === next($this->queues)) {
                reset($this->queues);
            }
            if ($envelope) {
                $this->envelopes->attach($envelope, $queue);
                break;
            } else {
                $checked[] = $queue;
            }
        }

        return $envelope;
    }

    /**
     * {@inheritdoc}
     */
    public function close()
    {
        if ($this->closed) {
            return;
        }

        foreach ($this->queues as $queue) {
            $queue->close();
        }

        $this->closed = true;
    }

    /**
     * {@inheritdoc}
     */
    public function peek($index = 0, $limit = 20)
    {
        $it = new \InfiniteIterator(new \ArrayIterator($this->queues));
        $envelopes = $drained = $indexes = [];
        foreach (array_keys($this->queues) as $name) {
            $indexes[$name] = 0;
        }
        $shift = 0;

        $key = key($this->queues);
        for ($it->rewind(); $it->key() != $key; $it->next()) {
            // noop
        }

        while (count($envelopes) < $limit && count($drained) < $it->count()) {
            $queue = $it->current();
            $name = $it->key();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
            if ($peeked = $queue->peek($indexes[$name], 1)) {
                if ($shift < $index) {
                    ++$shift;
                    ++$indexes[$name];
                } else {
                    $envelopes[] = array_shift($peeked);
                }
            } else {
                $drained[$name] = true;
            }
            $it->next();
        }

        return $envelopes;
    }

    /**
     * {@inheritdoc}
     */
    public function acknowledge(Envelope $envelope)
    {
        if (!$this->envelopes->contains($envelope)) {
            throw new \DomainException(
                'Unrecognized queue specified: '.$envelope->getName()
            );
        }

        $queue = $this->envelopes[$envelope];
        $queue->acknowledge($envelope);
        $this->envelopes->detach($envelope);
    }

    /**
     * {@inheritdoc}
     */
    public function __toString()
    {
        return (string) current($this->queues);
    }

    /**
     * @return int
     */
    public function count()
    {
        return array_sum(array_map('count', $this->queues));
    }

    /**
     * @param Queue[] $queues
     */
    protected function validateQueues(array $queues)
    {
        if (empty($queues)) {
            throw new \DomainException('$queues cannot be empty');
        }

        $filtered = array_filter(
            $queues,
            function ($queue) {
                return !$queue instanceof Queue;
            }
        );
        if (!empty($filtered)) {
            throw new \DomainException('All elements of $queues must implement Queue');
        }
    }

    /**
     * @param Queue[] $queues
     *
     * @return Queue[]
     */
    protected function indexQueues(array $queues)
    {
        return array_combine(
            array_map(
                function ($queue) {
                    return (string) $queue;
                },
                $queues
            ),
            $queues
        );
    }

    /**
     * @param Envelope $envelope
     */
    protected function verifyEnvelope(Envelope $envelope)
    {
        $queue = $envelope->getName();
        if (isset($this->queues[$queue])) {
            return;
        }
        throw new \DomainException('Unrecognized queue specified: '.$queue);
    }
}


1		<?php
2
3		namespace Bernard\Queue;
4
5		use Bernard\Envelope;
6		use Bernard\Queue;
7
8		class RoundRobinQueue implements Queue
9		{
10		/**
11		* @var Queue[]
12		*/
13		protected $queues;
14
15		/**
16		* @var bool
17		*/
18		protected $closed;
19
20		/**
21		* @var \SplObjectStorage
22		*/
23		protected $envelopes;
24
25		/**
26		* @param Queue[] $queues
27		*/
28	11	public function __construct(array $queues)
29		{
30	11	$this->validateQueues($queues);
31
32	11	$this->queues = $this->indexQueues($queues);
33	11	$this->envelopes = new \SplObjectStorage();
34	11	$this->closed = false;
35	11	}
36
37		/**
38		* {@inheritdoc}
39		*/
40	8	public function enqueue(Envelope $envelope)
41		{
42	8	$this->verifyEnvelope($envelope);
43
44	6	$this->queues[$envelope->getName()]->enqueue($envelope);
45	6	}
46
47		/**
48		* {@inheritdoc}
49		*/
50	5	public function dequeue()
51		{
52	5	$envelope = null;
53	5	$checked = [];
54
55	5	while (count($checked) < count($this->queues)) {
56	5	$queue = current($this->queues);
57	5	$envelope = $queue->dequeue();
58	5	if (false === next($this->queues)) {
59	2	reset($this->queues);
60	2	}
61	5	if ($envelope) {
62	4	$this->envelopes->attach($envelope, $queue);
63	4	break;
64		} else {
65	4	$checked[] = $queue;
66		}
67	4	}
68
69	5	return $envelope;
70		}
71
72		/**
73		* {@inheritdoc}
74		*/
75	1	public function close()
76		{
77	1	if ($this->closed) {
78		return;
79		}
80
81	1	foreach ($this->queues as $queue) {
82	1	$queue->close();
83	1	}
84
85	1	$this->closed = true;
86	1	}
87
88		/**
89		* {@inheritdoc}
90		*/
91	1	public function peek($index = 0, $limit = 20)
92		{
93	1	$it = new \InfiniteIterator(new \ArrayIterator($this->queues));
94	1	$envelopes = $drained = $indexes = [];
95	1	foreach (array_keys($this->queues) as $name) {
96	1	$indexes[$name] = 0;
97	1	}
98	1	$shift = 0;
99
100	1	$key = key($this->queues);
101	1	for ($it->rewind(); $it->key() != $key; $it->next()) {
102		// noop
103		}
104
105	1	while (count($envelopes) < $limit && count($drained) < $it->count()) {
106	1	$queue = $it->current();
107	1	$name = $it->key();
		0 ignored issues – show Bug introduced 2015-11-30 20:04 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$name` is correct as `$it->key()` (which targets `InfiniteIterator::key()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
108	1	if ($peeked = $queue->peek($indexes[$name], 1)) {
109	1	if ($shift < $index) {
110	1	++$shift;
111	1	++$indexes[$name];
112	1	} else {
113	1	$envelopes[] = array_shift($peeked);
114		}
115	1	} else {
116	1	$drained[$name] = true;
117		}
118	1	$it->next();
119	1	}
120
121	1	return $envelopes;
122		}
123
124		/**
125		* {@inheritdoc}
126		*/
127	1	public function acknowledge(Envelope $envelope)
128		{
129	1	if (!$this->envelopes->contains($envelope)) {
130		throw new \DomainException(
131		'Unrecognized queue specified: '.$envelope->getName()
132		);
133		}
134
135	1	$queue = $this->envelopes[$envelope];
136	1	$queue->acknowledge($envelope);
137	1	$this->envelopes->detach($envelope);
138	1	}
139
140		/**
141		* {@inheritdoc}
142		*/
143	1	public function __toString()
144		{
145	1	return (string) current($this->queues);
146		}
147
148		/**
149		* @return int
150		*/
151	1	public function count()
152		{
153	1	return array_sum(array_map('count', $this->queues));
154		}
155
156		/**
157		* @param Queue[] $queues
158		*/
159	11	protected function validateQueues(array $queues)
160		{
161	11	if (empty($queues)) {
162		throw new \DomainException('$queues cannot be empty');
163		}
164
165	11	$filtered = array_filter(
166	11	$queues,
167		function ($queue) {
168	11	return !$queue instanceof Queue;
169		}
170	11	);
171	11	if (!empty($filtered)) {
172		throw new \DomainException('All elements of $queues must implement Queue');
173		}
174	11	}
175
176		/**
177		* @param Queue[] $queues
178		*
179		* @return Queue[]
180		*/
181	11	protected function indexQueues(array $queues)
182		{
183	11	return array_combine(
184	11	array_map(
185	11	function ($queue) {
186	11	return (string) $queue;
187	11	},
188		$queues
189	11	),
190		$queues
191	11	);
192		}
193
194		/**
195		* @param Envelope $envelope
196		*/
197	8	protected function verifyEnvelope(Envelope $envelope)
198		{
199	8	$queue = $envelope->getName();
200	8	if (isset($this->queues[$queue])) {
201	6	return;
202		}
203	2	throw new \DomainException('Unrecognized queue specified: '.$queue);
204		}
205		}
206

bernardphp / bernard

GitHub Access Token became invalid

RoundRobinQueue::__construct() A last analyzed 2019-10-20 16:13 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

RoundRobinQueue::__construct() A
last analyzed 2019-10-20 16:13 UTC