InMemoryRule::getMinimumSiblingProcessorUsage() - Code Metrics - asyncphp/doorman - Measure and Improve Code Quality continuously with Scrutinizer

InMemoryRule::getMinimumSiblingProcessorUsage() A
last analyzed 2020-05-18 21:01 UTC

↳ Parent: InMemoryRule

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

namespace AsyncPHP\Doorman\Rule;

use AsyncPHP\Doorman\Rule;

final class InMemoryRule implements Rule
{
    /**
     * @var null|int
     */
    private $processes;

    /**
     * @var null|string
     */
    private $handler;

    /**
     * @var null|float
     */
    private $minimumProcessorUsage;

    /**
     * @var null|float
     */
    private $maximumProcessorUsage;

    /**
     * @var null|float
     */
    private $minimumMemoryUsage;

    /**
     * @var null|float
     */
    private $maximumMemoryUsage;

    /**
     * @var null|float
     */
    private $minimumSiblingProcessorUsage;

    /**
     * @var null|float
     */
    private $maximumSiblingProcessorUsage;

    /**
     * @var null|float
     */
    private $minimumSiblingMemoryUsage;

    /**
     * @var null|float
     */
    private $maximumSiblingMemoryUsage;

    /**
     * @inheritdoc
     *
     * @return int|null
     */
    public function getProcesses()
    {
        return $this->processes;
    }

    /**
     * @param int|null $processes
     *
     * @return $this
     */
    public function setProcesses($processes)
    {
        $this->processes = $processes;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|string
     */
    public function getHandler()
    {
        return $this->handler;
    }

    /**
     * @param null|string $handler
     *
     * @return $this
     */
    public function setHandler($handler)
    {
        $this->handler = $handler;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMinimumProcessorUsage()
    {
        return $this->minimumProcessorUsage;
    }

    /**
     * @param null|float $minimumProcessorUsage
     *
     * @return $this
     */
    public function setMinimumProcessorUsage($minimumProcessorUsage)
    {
        $this->minimumProcessorUsage = $minimumProcessorUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMaximumProcessorUsage()
    {
        return $this->maximumProcessorUsage;
    }

    /**
     * @param null|float $maximumProcessorUsage
     *
     * @return $this
     */
    public function setMaximumProcessorUsage($maximumProcessorUsage)
    {
        $this->maximumProcessorUsage = $maximumProcessorUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMinimumMemoryUsage()
    {
        return $this->minimumMemoryUsage;
    }

    /**
     * @param null|float $minimumMemoryUsage
     *
     * @return $this
     */
    public function setMinimumMemoryUsage($minimumMemoryUsage)
    {
        $this->minimumMemoryUsage = $minimumMemoryUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMaximumMemoryUsage()
    {
        return $this->maximumMemoryUsage;
    }

    /**
     * @param null|float $maximumMemoryUsage
     *
     * @return $this
     */
    public function setMaximumMemoryUsage($maximumMemoryUsage)
    {
        $this->maximumMemoryUsage = $maximumMemoryUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMinimumSiblingProcessorUsage()
    {
        return $this->minimumSiblingProcessorUsage;
    }

    /**
     * @param null|float $minimumSiblingProcessorUsage
     *
     * @return $this
     */
    public function setMinimumSiblingProcessorUsage($minimumSiblingProcessorUsage)
    {
        $this->minimumSiblingProcessorUsage = $minimumSiblingProcessorUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMaximumSiblingProcessorUsage()
    {
        return $this->maximumSiblingProcessorUsage;
    }

    /**
     * @param null|float $maximumSiblingProcessorUsage
     *
     * @return $this
     */
    public function setMaximumSiblingProcessorUsage($maximumSiblingProcessorUsage)
    {
        $this->maximumSiblingProcessorUsage = $maximumSiblingProcessorUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMinimumSiblingMemoryUsage()
    {
        return $this->minimumSiblingMemoryUsage;
    }

    /**
     * @param null|float $minimumSiblingMemoryUsage
     *
     * @return $this
     */
    public function setMinimumSiblingMemoryUsage($minimumSiblingMemoryUsage)
    {
        $this->minimumSiblingMemoryUsage = $minimumSiblingMemoryUsage;

        return $this;
    }

    /**
     * @inheritdoc
     *
     * @return null|float
     */
    public function getMaximumSiblingMemoryUsage()
    {
        return $this->maximumSiblingMemoryUsage;
    }

    /**
     * @param null|float $maximumSiblingMemoryUsage
     *
     * @return $this
     */
    public function setMaximumSiblingMemoryUsage($maximumSiblingMemoryUsage)
    {
        $this->maximumSiblingMemoryUsage = $maximumSiblingMemoryUsage;

        return $this;
    }
}


1		<?php
2
3		namespace AsyncPHP\Doorman\Rule;
4
5		use AsyncPHP\Doorman\Rule;
6
7		final class InMemoryRule implements Rule
8		{
9		/**
10		* @var null\|int
11		*/
12		private $processes;
13
14		/**
15		* @var null\|string
16		*/
17		private $handler;
18
19		/**
20		* @var null\|float
21		*/
22		private $minimumProcessorUsage;
23
24		/**
25		* @var null\|float
26		*/
27		private $maximumProcessorUsage;
28
29		/**
30		* @var null\|float
31		*/
32		private $minimumMemoryUsage;
33
34		/**
35		* @var null\|float
36		*/
37		private $maximumMemoryUsage;
38
39		/**
40		* @var null\|float
41		*/
42		private $minimumSiblingProcessorUsage;
43
44		/**
45		* @var null\|float
46		*/
47		private $maximumSiblingProcessorUsage;
48
49		/**
50		* @var null\|float
51		*/
52		private $minimumSiblingMemoryUsage;
53
54		/**
55		* @var null\|float
56		*/
57		private $maximumSiblingMemoryUsage;
58
59		/**
60		* @inheritdoc
61		*
62		* @return int\|null
63		*/
64	1	public function getProcesses()
65		{
66	1	return $this->processes;
67		}
68
69		/**
70		* @param int\|null $processes
71		*
72		* @return $this
73		*/
74	1	public function setProcesses($processes)
75		{
76	1	$this->processes = $processes;
77
78	1	return $this;
79		}
80
81		/**
82		* @inheritdoc
83		*
84		* @return null\|string
85		*/
86	1	public function getHandler()
87		{
88	1	return $this->handler;
89		}
90
91		/**
92		* @param null\|string $handler
93		*
94		* @return $this
95		*/
96	1	public function setHandler($handler)
97		{
98	1	$this->handler = $handler;
99
100	1	return $this;
101		}
102
103		/**
104		* @inheritdoc
105		*
106		* @return null\|float
107		*/
108	1	public function getMinimumProcessorUsage()
109		{
110	1	return $this->minimumProcessorUsage;
111		}
112
113		/**
114		* @param null\|float $minimumProcessorUsage
115		*
116		* @return $this
117		*/
118	1	public function setMinimumProcessorUsage($minimumProcessorUsage)
119		{
120	1	$this->minimumProcessorUsage = $minimumProcessorUsage;
121
122	1	return $this;
123		}
124
125		/**
126		* @inheritdoc
127		*
128		* @return null\|float
129		*/
130	1	public function getMaximumProcessorUsage()
131		{
132	1	return $this->maximumProcessorUsage;
133		}
134
135		/**
136		* @param null\|float $maximumProcessorUsage
137		*
138		* @return $this
139		*/
140	1	public function setMaximumProcessorUsage($maximumProcessorUsage)
141		{
142	1	$this->maximumProcessorUsage = $maximumProcessorUsage;
143
144	1	return $this;
145		}
146
147		/**
148		* @inheritdoc
149		*
150		* @return null\|float
151		*/
152	1	public function getMinimumMemoryUsage()
153		{
154	1	return $this->minimumMemoryUsage;
155		}
156
157		/**
158		* @param null\|float $minimumMemoryUsage
159		*
160		* @return $this
161		*/
162	1	public function setMinimumMemoryUsage($minimumMemoryUsage)
163		{
164	1	$this->minimumMemoryUsage = $minimumMemoryUsage;
165
166	1	return $this;
167		}
168
169		/**
170		* @inheritdoc
171		*
172		* @return null\|float
173		*/
174	1	public function getMaximumMemoryUsage()
175		{
176	1	return $this->maximumMemoryUsage;
177		}
178
179		/**
180		* @param null\|float $maximumMemoryUsage
181		*
182		* @return $this
183		*/
184	1	public function setMaximumMemoryUsage($maximumMemoryUsage)
185		{
186	1	$this->maximumMemoryUsage = $maximumMemoryUsage;
187
188	1	return $this;
189		}
190
191		/**
192		* @inheritdoc
193		*
194		* @return null\|float
195		*/
196	1	public function getMinimumSiblingProcessorUsage()
197		{
198	1	return $this->minimumSiblingProcessorUsage;
199		}
200
201		/**
202		* @param null\|float $minimumSiblingProcessorUsage
203		*
204		* @return $this
205		*/
206	1	public function setMinimumSiblingProcessorUsage($minimumSiblingProcessorUsage)
207		{
208	1	$this->minimumSiblingProcessorUsage = $minimumSiblingProcessorUsage;
209
210	1	return $this;
211		}
212
213		/**
214		* @inheritdoc
215		*
216		* @return null\|float
217		*/
218	1	public function getMaximumSiblingProcessorUsage()
219		{
220	1	return $this->maximumSiblingProcessorUsage;
221		}
222
223		/**
224		* @param null\|float $maximumSiblingProcessorUsage
225		*
226		* @return $this
227		*/
228	1	public function setMaximumSiblingProcessorUsage($maximumSiblingProcessorUsage)
229		{
230	1	$this->maximumSiblingProcessorUsage = $maximumSiblingProcessorUsage;
231
232	1	return $this;
233		}
234
235		/**
236		* @inheritdoc
237		*
238		* @return null\|float
239		*/
240	1	public function getMinimumSiblingMemoryUsage()
241		{
242	1	return $this->minimumSiblingMemoryUsage;
243		}
244
245		/**
246		* @param null\|float $minimumSiblingMemoryUsage
247		*
248		* @return $this
249		*/
250	1	public function setMinimumSiblingMemoryUsage($minimumSiblingMemoryUsage)
251		{
252	1	$this->minimumSiblingMemoryUsage = $minimumSiblingMemoryUsage;
253
254	1	return $this;
255		}
256
257		/**
258		* @inheritdoc
259		*
260		* @return null\|float
261		*/
262	1	public function getMaximumSiblingMemoryUsage()
263		{
264	1	return $this->maximumSiblingMemoryUsage;
265		}
266
267		/**
268		* @param null\|float $maximumSiblingMemoryUsage
269		*
270		* @return $this
271		*/
272	1	public function setMaximumSiblingMemoryUsage($maximumSiblingMemoryUsage)
273		{
274	1	$this->maximumSiblingMemoryUsage = $maximumSiblingMemoryUsage;
275
276	1	return $this;
277		}
278		}
279

asyncphp / doorman

InMemoryRule::getMinimumSiblingProcessorUsage() A last analyzed 2020-05-18 21:01 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

InMemoryRule::getMinimumSiblingProcessorUsage() A
last analyzed 2020-05-18 21:01 UTC