Scope - Code Metrics - Inspection of "- add abstract base" - CyberLine/systemd-state - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c21b15...51d90f )

by Alexander

created 2019-01-30 10:42 UTC

Scope F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	802
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

Metric	Value
wmc	80
lcom	0
cbo	1
dl	0
loc	802
rs	1.798
c	0
b	0
f	0

80 Methods

Rating	Name	Size	Complexity
A	getAfter()	4	1
A	setAfter()	5	1
A	getBlockIOAccounting()	4	1
A	setBlockIOAccounting()	5	1
A	getBlockIOWeight()	4	1
A	setBlockIOWeight()	5	1
A	getCPUAccounting()	4	1
A	setCPUAccounting()	5	1
A	getCPUQuotaPerSecUSec()	4	1
A	setCPUQuotaPerSecUSec()	5	1
A	getCPUShares()	4	1
A	setCPUShares()	5	1
A	getCPUUsageNSec()	4	1
A	setCPUUsageNSec()	5	1
A	getCPUWeight()	4	1
A	setCPUWeight()	5	1
A	getConflicts()	4	1
A	setConflicts()	5	1
A	getControlGroup()	4	1
A	setControlGroup()	5	1
A	getDelegate()	4	1
A	setDelegate()	5	1
A	getDevicePolicy()	4	1
A	setDevicePolicy()	5	1
A	getDocumentation()	4	1
A	setDocumentation()	5	1
A	getFragmentPath()	4	1
A	setFragmentPath()	5	1
A	getIOAccounting()	4	1
A	setIOAccounting()	5	1
A	getIOWeight()	4	1
A	setIOWeight()	5	1
A	getKillMode()	4	1
A	setKillMode()	5	1
A	getKillSignal()	4	1
A	setKillSignal()	5	1
A	getMemoryAccounting()	4	1
A	setMemoryAccounting()	5	1
A	getMemoryCurrent()	4	1
A	setMemoryCurrent()	5	1
A	getMemoryHigh()	4	1
A	setMemoryHigh()	5	1
A	getMemoryLimit()	4	1
A	setMemoryLimit()	5	1
A	getMemoryLow()	4	1
A	setMemoryLow()	5	1
A	getMemoryMax()	4	1
A	setMemoryMax()	5	1
A	getMemorySwapMax()	4	1
A	setMemorySwapMax()	5	1
A	getRequires()	4	1
A	setRequires()	5	1
A	getResult()	4	1
A	setResult()	5	1
A	getSendSIGHUP()	4	1
A	setSendSIGHUP()	5	1
A	getSendSIGKILL()	4	1
A	setSendSIGKILL()	5	1
A	getSlice()	4	1
A	setSlice()	5	1
A	getStartupBlockIOWeight()	4	1
A	setStartupBlockIOWeight()	5	1
A	getStartupCPUShares()	4	1
A	setStartupCPUShares()	5	1
A	getStartupCPUWeight()	4	1
A	setStartupCPUWeight()	5	1
A	getStartupIOWeight()	4	1
A	setStartupIOWeight()	5	1
A	getTasksAccounting()	4	1
A	setTasksAccounting()	5	1
A	getTasksCurrent()	4	1
A	setTasksCurrent()	5	1
A	getTasksMax()	4	1
A	setTasksMax()	5	1
A	getTimeoutStopUSec()	4	1
A	setTimeoutStopUSec()	5	1
A	getUnitFilePreset()	4	1
A	setUnitFilePreset()	5	1
A	getUnitFileState()	4	1
A	setUnitFileState()	5	1

How to fix Complexity

<?php

namespace CyberLine\SystemdState\Types;

class Scope extends AbstractType
{
    private $After = [];

    private $BlockIOAccounting;

    private $BlockIOWeight;

    private $CPUAccounting;

    private $CPUQuotaPerSecUSec;

    private $CPUShares;

    private $CPUUsageNSec;

    private $CPUWeight;

    private $Conflicts = [];

    private $ControlGroup;

    private $Delegate;

    private $DevicePolicy;

    private $Documentation;

    private $FragmentPath;

    private $IOAccounting;

    private $IOWeight;

    private $KillMode;

    private $KillSignal;

    private $MemoryAccounting;

    private $MemoryCurrent;

    private $MemoryHigh;

    private $MemoryLimit;

    private $MemoryLow;

    private $MemoryMax;

    private $MemorySwapMax;

    private $Requires = [];

    private $Result;

    private $SendSIGHUP;

    private $SendSIGKILL;

    private $Slice;

    private $StartupBlockIOWeight;

    private $StartupCPUShares;

    private $StartupCPUWeight;

    private $StartupIOWeight;

    private $TasksAccounting;

    private $TasksCurrent;

    private $TasksMax;

    private $TimeoutStopUSec;

    private $UnitFilePreset;

    private $UnitFileState;

    /**
     * @return array
     */
    public function getAfter(): array
    {
        return $this->After;
    }

    /**
     * @param array $After
     * @return Scope
     */
    public function setAfter(array $After): Scope
    {
        $this->After = $After;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getBlockIOAccounting()
    {
        return $this->BlockIOAccounting;
    }

    /**
     * @param mixed $BlockIOAccounting
     * @return Scope
     */
    public function setBlockIOAccounting($BlockIOAccounting)
    {
        $this->BlockIOAccounting = $BlockIOAccounting;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getBlockIOWeight()
    {
        return $this->BlockIOWeight;
    }

    /**
     * @param mixed $BlockIOWeight
     * @return Scope
     */
    public function setBlockIOWeight($BlockIOWeight)
    {
        $this->BlockIOWeight = $BlockIOWeight;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getCPUAccounting()
    {
        return $this->CPUAccounting;
    }

    /**
     * @param mixed $CPUAccounting
     * @return Scope
     */
    public function setCPUAccounting($CPUAccounting)
    {
        $this->CPUAccounting = $CPUAccounting;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getCPUQuotaPerSecUSec()
    {
        return $this->CPUQuotaPerSecUSec;
    }

    /**
     * @param mixed $CPUQuotaPerSecUSec
     * @return Scope
     */
    public function setCPUQuotaPerSecUSec($CPUQuotaPerSecUSec)
    {
        $this->CPUQuotaPerSecUSec = $CPUQuotaPerSecUSec;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getCPUShares()
    {
        return $this->CPUShares;
    }

    /**
     * @param mixed $CPUShares
     * @return Scope
     */
    public function setCPUShares($CPUShares)
    {
        $this->CPUShares = $CPUShares;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getCPUUsageNSec()
    {
        return $this->CPUUsageNSec;
    }

    /**
     * @param mixed $CPUUsageNSec
     * @return Scope
     */
    public function setCPUUsageNSec($CPUUsageNSec)
    {
        $this->CPUUsageNSec = $CPUUsageNSec;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getCPUWeight()
    {
        return $this->CPUWeight;
    }

    /**
     * @param mixed $CPUWeight
     * @return Scope
     */
    public function setCPUWeight($CPUWeight)
    {
        $this->CPUWeight = $CPUWeight;
        return $this;
    }

    /**
     * @return array
     */
    public function getConflicts(): array
    {
        return $this->Conflicts;
    }

    /**
     * @param array $Conflicts
     * @return Scope
     */
    public function setConflicts(array $Conflicts): Scope
    {
        $this->Conflicts = $Conflicts;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getControlGroup()
    {
        return $this->ControlGroup;
    }

    /**
     * @param mixed $ControlGroup
     * @return Scope
     */
    public function setControlGroup($ControlGroup)
    {
        $this->ControlGroup = $ControlGroup;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getDelegate()
    {
        return $this->Delegate;
    }

    /**
     * @param mixed $Delegate
     * @return Scope
     */
    public function setDelegate($Delegate)
    {
        $this->Delegate = $Delegate;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getDevicePolicy()
    {
        return $this->DevicePolicy;
    }

    /**
     * @param mixed $DevicePolicy
     * @return Scope
     */
    public function setDevicePolicy($DevicePolicy)
    {
        $this->DevicePolicy = $DevicePolicy;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getDocumentation()
    {
        return $this->Documentation;
    }

    /**
     * @param mixed $Documentation
     * @return Scope
     */
    public function setDocumentation($Documentation)
    {
        $this->Documentation = $Documentation;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getFragmentPath()
    {
        return $this->FragmentPath;
    }

    /**
     * @param mixed $FragmentPath
     * @return Scope
     */
    public function setFragmentPath($FragmentPath)
    {
        $this->FragmentPath = $FragmentPath;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getIOAccounting()
    {
        return $this->IOAccounting;
    }

    /**
     * @param mixed $IOAccounting
     * @return Scope
     */
    public function setIOAccounting($IOAccounting)
    {
        $this->IOAccounting = $IOAccounting;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getIOWeight()
    {
        return $this->IOWeight;
    }

    /**
     * @param mixed $IOWeight
     * @return Scope
     */
    public function setIOWeight($IOWeight)
    {
        $this->IOWeight = $IOWeight;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getKillMode()
    {
        return $this->KillMode;
    }

    /**
     * @param mixed $KillMode
     * @return Scope
     */
    public function setKillMode($KillMode)
    {
        $this->KillMode = $KillMode;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getKillSignal()
    {
        return $this->KillSignal;
    }

    /**
     * @param mixed $KillSignal
     * @return Scope
     */
    public function setKillSignal($KillSignal)
    {
        $this->KillSignal = $KillSignal;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemoryAccounting()
    {
        return $this->MemoryAccounting;
    }

    /**
     * @param mixed $MemoryAccounting
     * @return Scope
     */
    public function setMemoryAccounting($MemoryAccounting)
    {
        $this->MemoryAccounting = $MemoryAccounting;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemoryCurrent()
    {
        return $this->MemoryCurrent;
    }

    /**
     * @param mixed $MemoryCurrent
     * @return Scope
     */
    public function setMemoryCurrent($MemoryCurrent)
    {
        $this->MemoryCurrent = $MemoryCurrent;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemoryHigh()
    {
        return $this->MemoryHigh;
    }

    /**
     * @param mixed $MemoryHigh
     * @return Scope
     */
    public function setMemoryHigh($MemoryHigh)
    {
        $this->MemoryHigh = $MemoryHigh;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemoryLimit()
    {
        return $this->MemoryLimit;
    }

    /**
     * @param mixed $MemoryLimit
     * @return Scope
     */
    public function setMemoryLimit($MemoryLimit)
    {
        $this->MemoryLimit = $MemoryLimit;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemoryLow()
    {
        return $this->MemoryLow;
    }

    /**
     * @param mixed $MemoryLow
     * @return Scope
     */
    public function setMemoryLow($MemoryLow)
    {
        $this->MemoryLow = $MemoryLow;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemoryMax()
    {
        return $this->MemoryMax;
    }

    /**
     * @param mixed $MemoryMax
     * @return Scope
     */
    public function setMemoryMax($MemoryMax)
    {
        $this->MemoryMax = $MemoryMax;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMemorySwapMax()
    {
        return $this->MemorySwapMax;
    }

    /**
     * @param mixed $MemorySwapMax
     * @return Scope
     */
    public function setMemorySwapMax($MemorySwapMax)
    {
        $this->MemorySwapMax = $MemorySwapMax;
        return $this;
    }

    /**
     * @return array
     */
    public function getRequires(): array
    {
        return $this->Requires;
    }

    /**
     * @param array $Requires
     * @return Scope
     */
    public function setRequires(array $Requires): Scope
    {
        $this->Requires = $Requires;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getResult()
    {
        return $this->Result;
    }

    /**
     * @param mixed $Result
     * @return Scope
     */
    public function setResult($Result)
    {
        $this->Result = $Result;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getSendSIGHUP()
    {
        return $this->SendSIGHUP;
    }

    /**
     * @param mixed $SendSIGHUP
     * @return Scope
     */
    public function setSendSIGHUP($SendSIGHUP)
    {
        $this->SendSIGHUP = $SendSIGHUP;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getSendSIGKILL()
    {
        return $this->SendSIGKILL;
    }

    /**
     * @param mixed $SendSIGKILL
     * @return Scope
     */
    public function setSendSIGKILL($SendSIGKILL)
    {
        $this->SendSIGKILL = $SendSIGKILL;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getSlice()
    {
        return $this->Slice;
    }

    /**
     * @param mixed $Slice
     * @return Scope
     */
    public function setSlice($Slice)
    {
        $this->Slice = $Slice;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getStartupBlockIOWeight()
    {
        return $this->StartupBlockIOWeight;
    }

    /**
     * @param mixed $StartupBlockIOWeight
     * @return Scope
     */
    public function setStartupBlockIOWeight($StartupBlockIOWeight)
    {
        $this->StartupBlockIOWeight = $StartupBlockIOWeight;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getStartupCPUShares()
    {
        return $this->StartupCPUShares;
    }

    /**
     * @param mixed $StartupCPUShares
     * @return Scope
     */
    public function setStartupCPUShares($StartupCPUShares)
    {
        $this->StartupCPUShares = $StartupCPUShares;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getStartupCPUWeight()
    {
        return $this->StartupCPUWeight;
    }

    /**
     * @param mixed $StartupCPUWeight
     * @return Scope
     */
    public function setStartupCPUWeight($StartupCPUWeight)
    {
        $this->StartupCPUWeight = $StartupCPUWeight;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getStartupIOWeight()
    {
        return $this->StartupIOWeight;
    }

    /**
     * @param mixed $StartupIOWeight
     * @return Scope
     */
    public function setStartupIOWeight($StartupIOWeight)
    {
        $this->StartupIOWeight = $StartupIOWeight;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getTasksAccounting()
    {
        return $this->TasksAccounting;
    }

    /**
     * @param mixed $TasksAccounting
     * @return Scope
     */
    public function setTasksAccounting($TasksAccounting)
    {
        $this->TasksAccounting = $TasksAccounting;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getTasksCurrent()
    {
        return $this->TasksCurrent;
    }

    /**
     * @param mixed $TasksCurrent
     * @return Scope
     */
    public function setTasksCurrent($TasksCurrent)
    {
        $this->TasksCurrent = $TasksCurrent;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getTasksMax()
    {
        return $this->TasksMax;
    }

    /**
     * @param mixed $TasksMax
     * @return Scope
     */
    public function setTasksMax($TasksMax)
    {
        $this->TasksMax = $TasksMax;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getTimeoutStopUSec()
    {
        return $this->TimeoutStopUSec;
    }

    /**
     * @param mixed $TimeoutStopUSec
     * @return Scope
     */
    public function setTimeoutStopUSec($TimeoutStopUSec)
    {
        $this->TimeoutStopUSec = $TimeoutStopUSec;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getUnitFilePreset()
    {
        return $this->UnitFilePreset;
    }

    /**
     * @param mixed $UnitFilePreset
     * @return Scope
     */
    public function setUnitFilePreset($UnitFilePreset)
    {
        $this->UnitFilePreset = $UnitFilePreset;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getUnitFileState()
    {
        return $this->UnitFileState;
    }

    /**
     * @param mixed $UnitFileState
     * @return Scope
     */
    public function setUnitFileState($UnitFileState)
    {
        $this->UnitFileState = $UnitFileState;
        return $this;
    }
}


1			<?php
2
3			namespace CyberLine\SystemdState\Types;
4
5			class Scope extends AbstractType
6			{
7			private $After = [];
8
9			private $BlockIOAccounting;
10
11			private $BlockIOWeight;
12
13			private $CPUAccounting;
14
15			private $CPUQuotaPerSecUSec;
16
17			private $CPUShares;
18
19			private $CPUUsageNSec;
20
21			private $CPUWeight;
22
23			private $Conflicts = [];
24
25			private $ControlGroup;
26
27			private $Delegate;
28
29			private $DevicePolicy;
30
31			private $Documentation;
32
33			private $FragmentPath;
34
35			private $IOAccounting;
36
37			private $IOWeight;
38
39			private $KillMode;
40
41			private $KillSignal;
42
43			private $MemoryAccounting;
44
45			private $MemoryCurrent;
46
47			private $MemoryHigh;
48
49			private $MemoryLimit;
50
51			private $MemoryLow;
52
53			private $MemoryMax;
54
55			private $MemorySwapMax;
56
57			private $Requires = [];
58
59			private $Result;
60
61			private $SendSIGHUP;
62
63			private $SendSIGKILL;
64
65			private $Slice;
66
67			private $StartupBlockIOWeight;
68
69			private $StartupCPUShares;
70
71			private $StartupCPUWeight;
72
73			private $StartupIOWeight;
74
75			private $TasksAccounting;
76
77			private $TasksCurrent;
78
79			private $TasksMax;
80
81			private $TimeoutStopUSec;
82
83			private $UnitFilePreset;
84
85			private $UnitFileState;
86
87			/**
88			* @return array
89			*/
90			public function getAfter(): array
91			{
92			return $this->After;
93			}
94
95			/**
96			* @param array $After
97			* @return Scope
98			*/
99			public function setAfter(array $After): Scope
100			{
101			$this->After = $After;
102			return $this;
103			}
104
105			/**
106			* @return mixed
107			*/
108			public function getBlockIOAccounting()
109			{
110			return $this->BlockIOAccounting;
111			}
112
113			/**
114			* @param mixed $BlockIOAccounting
115			* @return Scope
116			*/
117			public function setBlockIOAccounting($BlockIOAccounting)
118			{
119			$this->BlockIOAccounting = $BlockIOAccounting;
120			return $this;
121			}
122
123			/**
124			* @return mixed
125			*/
126			public function getBlockIOWeight()
127			{
128			return $this->BlockIOWeight;
129			}
130
131			/**
132			* @param mixed $BlockIOWeight
133			* @return Scope
134			*/
135			public function setBlockIOWeight($BlockIOWeight)
136			{
137			$this->BlockIOWeight = $BlockIOWeight;
138			return $this;
139			}
140
141			/**
142			* @return mixed
143			*/
144			public function getCPUAccounting()
145			{
146			return $this->CPUAccounting;
147			}
148
149			/**
150			* @param mixed $CPUAccounting
151			* @return Scope
152			*/
153			public function setCPUAccounting($CPUAccounting)
154			{
155			$this->CPUAccounting = $CPUAccounting;
156			return $this;
157			}
158
159			/**
160			* @return mixed
161			*/
162			public function getCPUQuotaPerSecUSec()
163			{
164			return $this->CPUQuotaPerSecUSec;
165			}
166
167			/**
168			* @param mixed $CPUQuotaPerSecUSec
169			* @return Scope
170			*/
171			public function setCPUQuotaPerSecUSec($CPUQuotaPerSecUSec)
172			{
173			$this->CPUQuotaPerSecUSec = $CPUQuotaPerSecUSec;
174			return $this;
175			}
176
177			/**
178			* @return mixed
179			*/
180			public function getCPUShares()
181			{
182			return $this->CPUShares;
183			}
184
185			/**
186			* @param mixed $CPUShares
187			* @return Scope
188			*/
189			public function setCPUShares($CPUShares)
190			{
191			$this->CPUShares = $CPUShares;
192			return $this;
193			}
194
195			/**
196			* @return mixed
197			*/
198			public function getCPUUsageNSec()
199			{
200			return $this->CPUUsageNSec;
201			}
202
203			/**
204			* @param mixed $CPUUsageNSec
205			* @return Scope
206			*/
207			public function setCPUUsageNSec($CPUUsageNSec)
208			{
209			$this->CPUUsageNSec = $CPUUsageNSec;
210			return $this;
211			}
212
213			/**
214			* @return mixed
215			*/
216			public function getCPUWeight()
217			{
218			return $this->CPUWeight;
219			}
220
221			/**
222			* @param mixed $CPUWeight
223			* @return Scope
224			*/
225			public function setCPUWeight($CPUWeight)
226			{
227			$this->CPUWeight = $CPUWeight;
228			return $this;
229			}
230
231			/**
232			* @return array
233			*/
234			public function getConflicts(): array
235			{
236			return $this->Conflicts;
237			}
238
239			/**
240			* @param array $Conflicts
241			* @return Scope
242			*/
243			public function setConflicts(array $Conflicts): Scope
244			{
245			$this->Conflicts = $Conflicts;
246			return $this;
247			}
248
249			/**
250			* @return mixed
251			*/
252			public function getControlGroup()
253			{
254			return $this->ControlGroup;
255			}
256
257			/**
258			* @param mixed $ControlGroup
259			* @return Scope
260			*/
261			public function setControlGroup($ControlGroup)
262			{
263			$this->ControlGroup = $ControlGroup;
264			return $this;
265			}
266
267			/**
268			* @return mixed
269			*/
270			public function getDelegate()
271			{
272			return $this->Delegate;
273			}
274
275			/**
276			* @param mixed $Delegate
277			* @return Scope
278			*/
279			public function setDelegate($Delegate)
280			{
281			$this->Delegate = $Delegate;
282			return $this;
283			}
284
285			/**
286			* @return mixed
287			*/
288			public function getDevicePolicy()
289			{
290			return $this->DevicePolicy;
291			}
292
293			/**
294			* @param mixed $DevicePolicy
295			* @return Scope
296			*/
297			public function setDevicePolicy($DevicePolicy)
298			{
299			$this->DevicePolicy = $DevicePolicy;
300			return $this;
301			}
302
303			/**
304			* @return mixed
305			*/
306			public function getDocumentation()
307			{
308			return $this->Documentation;
309			}
310
311			/**
312			* @param mixed $Documentation
313			* @return Scope
314			*/
315			public function setDocumentation($Documentation)
316			{
317			$this->Documentation = $Documentation;
318			return $this;
319			}
320
321			/**
322			* @return mixed
323			*/
324			public function getFragmentPath()
325			{
326			return $this->FragmentPath;
327			}
328
329			/**
330			* @param mixed $FragmentPath
331			* @return Scope
332			*/
333			public function setFragmentPath($FragmentPath)
334			{
335			$this->FragmentPath = $FragmentPath;
336			return $this;
337			}
338
339			/**
340			* @return mixed
341			*/
342			public function getIOAccounting()
343			{
344			return $this->IOAccounting;
345			}
346
347			/**
348			* @param mixed $IOAccounting
349			* @return Scope
350			*/
351			public function setIOAccounting($IOAccounting)
352			{
353			$this->IOAccounting = $IOAccounting;
354			return $this;
355			}
356
357			/**
358			* @return mixed
359			*/
360			public function getIOWeight()
361			{
362			return $this->IOWeight;
363			}
364
365			/**
366			* @param mixed $IOWeight
367			* @return Scope
368			*/
369			public function setIOWeight($IOWeight)
370			{
371			$this->IOWeight = $IOWeight;
372			return $this;
373			}
374
375			/**
376			* @return mixed
377			*/
378			public function getKillMode()
379			{
380			return $this->KillMode;
381			}
382
383			/**
384			* @param mixed $KillMode
385			* @return Scope
386			*/
387			public function setKillMode($KillMode)
388			{
389			$this->KillMode = $KillMode;
390			return $this;
391			}
392
393			/**
394			* @return mixed
395			*/
396			public function getKillSignal()
397			{
398			return $this->KillSignal;
399			}
400
401			/**
402			* @param mixed $KillSignal
403			* @return Scope
404			*/
405			public function setKillSignal($KillSignal)
406			{
407			$this->KillSignal = $KillSignal;
408			return $this;
409			}
410
411			/**
412			* @return mixed
413			*/
414			public function getMemoryAccounting()
415			{
416			return $this->MemoryAccounting;
417			}
418
419			/**
420			* @param mixed $MemoryAccounting
421			* @return Scope
422			*/
423			public function setMemoryAccounting($MemoryAccounting)
424			{
425			$this->MemoryAccounting = $MemoryAccounting;
426			return $this;
427			}
428
429			/**
430			* @return mixed
431			*/
432			public function getMemoryCurrent()
433			{
434			return $this->MemoryCurrent;
435			}
436
437			/**
438			* @param mixed $MemoryCurrent
439			* @return Scope
440			*/
441			public function setMemoryCurrent($MemoryCurrent)
442			{
443			$this->MemoryCurrent = $MemoryCurrent;
444			return $this;
445			}
446
447			/**
448			* @return mixed
449			*/
450			public function getMemoryHigh()
451			{
452			return $this->MemoryHigh;
453			}
454
455			/**
456			* @param mixed $MemoryHigh
457			* @return Scope
458			*/
459			public function setMemoryHigh($MemoryHigh)
460			{
461			$this->MemoryHigh = $MemoryHigh;
462			return $this;
463			}
464
465			/**
466			* @return mixed
467			*/
468			public function getMemoryLimit()
469			{
470			return $this->MemoryLimit;
471			}
472
473			/**
474			* @param mixed $MemoryLimit
475			* @return Scope
476			*/
477			public function setMemoryLimit($MemoryLimit)
478			{
479			$this->MemoryLimit = $MemoryLimit;
480			return $this;
481			}
482
483			/**
484			* @return mixed
485			*/
486			public function getMemoryLow()
487			{
488			return $this->MemoryLow;
489			}
490
491			/**
492			* @param mixed $MemoryLow
493			* @return Scope
494			*/
495			public function setMemoryLow($MemoryLow)
496			{
497			$this->MemoryLow = $MemoryLow;
498			return $this;
499			}
500
501			/**
502			* @return mixed
503			*/
504			public function getMemoryMax()
505			{
506			return $this->MemoryMax;
507			}
508
509			/**
510			* @param mixed $MemoryMax
511			* @return Scope
512			*/
513			public function setMemoryMax($MemoryMax)
514			{
515			$this->MemoryMax = $MemoryMax;
516			return $this;
517			}
518
519			/**
520			* @return mixed
521			*/
522			public function getMemorySwapMax()
523			{
524			return $this->MemorySwapMax;
525			}
526
527			/**
528			* @param mixed $MemorySwapMax
529			* @return Scope
530			*/
531			public function setMemorySwapMax($MemorySwapMax)
532			{
533			$this->MemorySwapMax = $MemorySwapMax;
534			return $this;
535			}
536
537			/**
538			* @return array
539			*/
540			public function getRequires(): array
541			{
542			return $this->Requires;
543			}
544
545			/**
546			* @param array $Requires
547			* @return Scope
548			*/
549			public function setRequires(array $Requires): Scope
550			{
551			$this->Requires = $Requires;
552			return $this;
553			}
554
555			/**
556			* @return mixed
557			*/
558			public function getResult()
559			{
560			return $this->Result;
561			}
562
563			/**
564			* @param mixed $Result
565			* @return Scope
566			*/
567			public function setResult($Result)
568			{
569			$this->Result = $Result;
570			return $this;
571			}
572
573			/**
574			* @return mixed
575			*/
576			public function getSendSIGHUP()
577			{
578			return $this->SendSIGHUP;
579			}
580
581			/**
582			* @param mixed $SendSIGHUP
583			* @return Scope
584			*/
585			public function setSendSIGHUP($SendSIGHUP)
586			{
587			$this->SendSIGHUP = $SendSIGHUP;
588			return $this;
589			}
590
591			/**
592			* @return mixed
593			*/
594			public function getSendSIGKILL()
595			{
596			return $this->SendSIGKILL;
597			}
598
599			/**
600			* @param mixed $SendSIGKILL
601			* @return Scope
602			*/
603			public function setSendSIGKILL($SendSIGKILL)
604			{
605			$this->SendSIGKILL = $SendSIGKILL;
606			return $this;
607			}
608
609			/**
610			* @return mixed
611			*/
612			public function getSlice()
613			{
614			return $this->Slice;
615			}
616
617			/**
618			* @param mixed $Slice
619			* @return Scope
620			*/
621			public function setSlice($Slice)
622			{
623			$this->Slice = $Slice;
624			return $this;
625			}
626
627			/**
628			* @return mixed
629			*/
630			public function getStartupBlockIOWeight()
631			{
632			return $this->StartupBlockIOWeight;
633			}
634
635			/**
636			* @param mixed $StartupBlockIOWeight
637			* @return Scope
638			*/
639			public function setStartupBlockIOWeight($StartupBlockIOWeight)
640			{
641			$this->StartupBlockIOWeight = $StartupBlockIOWeight;
642			return $this;
643			}
644
645			/**
646			* @return mixed
647			*/
648			public function getStartupCPUShares()
649			{
650			return $this->StartupCPUShares;
651			}
652
653			/**
654			* @param mixed $StartupCPUShares
655			* @return Scope
656			*/
657			public function setStartupCPUShares($StartupCPUShares)
658			{
659			$this->StartupCPUShares = $StartupCPUShares;
660			return $this;
661			}
662
663			/**
664			* @return mixed
665			*/
666			public function getStartupCPUWeight()
667			{
668			return $this->StartupCPUWeight;
669			}
670
671			/**
672			* @param mixed $StartupCPUWeight
673			* @return Scope
674			*/
675			public function setStartupCPUWeight($StartupCPUWeight)
676			{
677			$this->StartupCPUWeight = $StartupCPUWeight;
678			return $this;
679			}
680
681			/**
682			* @return mixed
683			*/
684			public function getStartupIOWeight()
685			{
686			return $this->StartupIOWeight;
687			}
688
689			/**
690			* @param mixed $StartupIOWeight
691			* @return Scope
692			*/
693			public function setStartupIOWeight($StartupIOWeight)
694			{
695			$this->StartupIOWeight = $StartupIOWeight;
696			return $this;
697			}
698
699			/**
700			* @return mixed
701			*/
702			public function getTasksAccounting()
703			{
704			return $this->TasksAccounting;
705			}
706
707			/**
708			* @param mixed $TasksAccounting
709			* @return Scope
710			*/
711			public function setTasksAccounting($TasksAccounting)
712			{
713			$this->TasksAccounting = $TasksAccounting;
714			return $this;
715			}
716
717			/**
718			* @return mixed
719			*/
720			public function getTasksCurrent()
721			{
722			return $this->TasksCurrent;
723			}
724
725			/**
726			* @param mixed $TasksCurrent
727			* @return Scope
728			*/
729			public function setTasksCurrent($TasksCurrent)
730			{
731			$this->TasksCurrent = $TasksCurrent;
732			return $this;
733			}
734
735			/**
736			* @return mixed
737			*/
738			public function getTasksMax()
739			{
740			return $this->TasksMax;
741			}
742
743			/**
744			* @param mixed $TasksMax
745			* @return Scope
746			*/
747			public function setTasksMax($TasksMax)
748			{
749			$this->TasksMax = $TasksMax;
750			return $this;
751			}
752
753			/**
754			* @return mixed
755			*/
756			public function getTimeoutStopUSec()
757			{
758			return $this->TimeoutStopUSec;
759			}
760
761			/**
762			* @param mixed $TimeoutStopUSec
763			* @return Scope
764			*/
765			public function setTimeoutStopUSec($TimeoutStopUSec)
766			{
767			$this->TimeoutStopUSec = $TimeoutStopUSec;
768			return $this;
769			}
770
771			/**
772			* @return mixed
773			*/
774			public function getUnitFilePreset()
775			{
776			return $this->UnitFilePreset;
777			}
778
779			/**
780			* @param mixed $UnitFilePreset
781			* @return Scope
782			*/
783			public function setUnitFilePreset($UnitFilePreset)
784			{
785			$this->UnitFilePreset = $UnitFilePreset;
786			return $this;
787			}
788
789			/**
790			* @return mixed
791			*/
792			public function getUnitFileState()
793			{
794			return $this->UnitFileState;
795			}
796
797			/**
798			* @param mixed $UnitFileState
799			* @return Scope
800			*/
801			public function setUnitFileState($UnitFileState)
802			{
803			$this->UnitFileState = $UnitFileState;
804			return $this;
805			}
806			}
807

CyberLine / systemd-state

Push — master ( c21b15...51d90f )

Scope F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

80 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like