Scope - Code Metrics - Inspection of "- ubuntu compatibility added" - CyberLine/systemd-state - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5f68f7...766e2f )

by Alexander

created 2019-01-30 21:43 UTC

Scope F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	822
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

Metric	Value
wmc	82
lcom	0
cbo	1
dl	0
loc	822
rs	1.778
c	0
b	0
f	0

82 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	getDropInPaths()	4	1
A	setDropInPaths()	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
{
    protected $After = [];

    protected $BlockIOAccounting;

    protected $BlockIOWeight;

    protected $CPUAccounting;

    protected $CPUQuotaPerSecUSec;

    protected $CPUShares;

    protected $CPUUsageNSec;

    protected $CPUWeight;

    protected $Conflicts = [];

    protected $ControlGroup;

    protected $Delegate;

    protected $DevicePolicy;

    protected $Documentation;

    protected $DropInPaths = [];

    protected $FragmentPath;

    protected $IOAccounting;

    protected $IOWeight;

    protected $KillMode;

    protected $KillSignal;

    protected $MemoryAccounting;

    protected $MemoryCurrent;

    protected $MemoryHigh;

    protected $MemoryLimit;

    protected $MemoryLow;

    protected $MemoryMax;

    protected $MemorySwapMax;

    protected $Requires = [];

    protected $Result;

    protected $SendSIGHUP;

    protected $SendSIGKILL;

    protected $Slice;

    protected $StartupBlockIOWeight;

    protected $StartupCPUShares;

    protected $StartupCPUWeight;

    protected $StartupIOWeight;

    protected $TasksAccounting;

    protected $TasksCurrent;

    protected $TasksMax;

    protected $TimeoutStopUSec;

    protected $UnitFilePreset;

    protected $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 array
     */
    public function getDropInPaths(): array
    {
        return $this->DropInPaths;
    }

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

CyberLine / systemd-state

Push — master ( 5f68f7...766e2f )

Scope F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

82 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like