Path::setRequires() - 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

Path::setRequires() A

↳ Parent: Path

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
c	0
b	0
f	0
rs	10
cc	1
nc	1
nop	1

<?php

namespace CyberLine\SystemdState\Types;

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

    private $Conflicts = [];

    private $DirectoryMode;

    private $DirectoryNotEmpty;

    private $Documentation = [];

    private $FragmentPath;

    private $MakeDirectory;

    private $Requires = [];

    private $RequiresMountsFor = [];

    private $Result;

    private $Triggers = [];

    private $Unit;

    private $UnitFilePreset;

    private $UnitFileState;

    private $WantedBy = [];

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

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

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

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

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

    /**
     * @param mixed $DirectoryMode
     * @return Path
     */
    public function setDirectoryMode($DirectoryMode)
    {
        $this->DirectoryMode = $DirectoryMode;
        return $this;
    }

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

    /**
     * @param mixed $DirectoryNotEmpty
     * @return Path
     */
    public function setDirectoryNotEmpty($DirectoryNotEmpty)
    {
        $this->DirectoryNotEmpty = $DirectoryNotEmpty;
        return $this;
    }

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

    /**
     * @param array $Documentation
     * @return Path
     */
    public function setDocumentation(array $Documentation): Path
    {
        $this->Documentation = $Documentation;
        return $this;
    }

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

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

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

    /**
     * @param mixed $MakeDirectory
     * @return Path
     */
    public function setMakeDirectory($MakeDirectory)
    {
        $this->MakeDirectory = $MakeDirectory;
        return $this;
    }

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

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

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

    /**
     * @param array $RequiresMountsFor
     * @return Path
     */
    public function setRequiresMountsFor(array $RequiresMountsFor): Path
    {
        $this->RequiresMountsFor = $RequiresMountsFor;
        return $this;
    }

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

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

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

    /**
     * @param array $Triggers
     * @return Path
     */
    public function setTriggers(array $Triggers): Path
    {
        $this->Triggers = $Triggers;
        return $this;
    }

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

    /**
     * @param mixed $Unit
     * @return Path
     */
    public function setUnit($Unit)
    {
        $this->Unit = $Unit;
        return $this;
    }

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

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

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

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

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

    /**
     * @param array $WantedBy
     * @return Path
     */
    public function setWantedBy(array $WantedBy): Path
    {
        $this->WantedBy = $WantedBy;
        return $this;
    }
}


1			<?php
2
3			namespace CyberLine\SystemdState\Types;
4
5			class Path extends AbstractType
6			{
7			private $After = [];
8
9			private $Conflicts = [];
10
11			private $DirectoryMode;
12
13			private $DirectoryNotEmpty;
14
15			private $Documentation = [];
16
17			private $FragmentPath;
18
19			private $MakeDirectory;
20
21			private $Requires = [];
22
23			private $RequiresMountsFor = [];
24
25			private $Result;
26
27			private $Triggers = [];
28
29			private $Unit;
30
31			private $UnitFilePreset;
32
33			private $UnitFileState;
34
35			private $WantedBy = [];
36
37			/**
38			* @return array
39			*/
40			public function getAfter(): array
41			{
42			return $this->After;
43			}
44
45			/**
46			* @param array $After
47			* @return Path
48			*/
49			public function setAfter(array $After): Path
50			{
51			$this->After = $After;
52			return $this;
53			}
54
55			/**
56			* @return array
57			*/
58			public function getConflicts(): array
59			{
60			return $this->Conflicts;
61			}
62
63			/**
64			* @param array $Conflicts
65			* @return Path
66			*/
67			public function setConflicts(array $Conflicts): Path
68			{
69			$this->Conflicts = $Conflicts;
70			return $this;
71			}
72
73			/**
74			* @return mixed
75			*/
76			public function getDirectoryMode()
77			{
78			return $this->DirectoryMode;
79			}
80
81			/**
82			* @param mixed $DirectoryMode
83			* @return Path
84			*/
85			public function setDirectoryMode($DirectoryMode)
86			{
87			$this->DirectoryMode = $DirectoryMode;
88			return $this;
89			}
90
91			/**
92			* @return mixed
93			*/
94			public function getDirectoryNotEmpty()
95			{
96			return $this->DirectoryNotEmpty;
97			}
98
99			/**
100			* @param mixed $DirectoryNotEmpty
101			* @return Path
102			*/
103			public function setDirectoryNotEmpty($DirectoryNotEmpty)
104			{
105			$this->DirectoryNotEmpty = $DirectoryNotEmpty;
106			return $this;
107			}
108
109			/**
110			* @return array
111			*/
112			public function getDocumentation(): array
113			{
114			return $this->Documentation;
115			}
116
117			/**
118			* @param array $Documentation
119			* @return Path
120			*/
121			public function setDocumentation(array $Documentation): Path
122			{
123			$this->Documentation = $Documentation;
124			return $this;
125			}
126
127			/**
128			* @return mixed
129			*/
130			public function getFragmentPath()
131			{
132			return $this->FragmentPath;
133			}
134
135			/**
136			* @param mixed $FragmentPath
137			* @return Path
138			*/
139			public function setFragmentPath($FragmentPath)
140			{
141			$this->FragmentPath = $FragmentPath;
142			return $this;
143			}
144
145			/**
146			* @return mixed
147			*/
148			public function getMakeDirectory()
149			{
150			return $this->MakeDirectory;
151			}
152
153			/**
154			* @param mixed $MakeDirectory
155			* @return Path
156			*/
157			public function setMakeDirectory($MakeDirectory)
158			{
159			$this->MakeDirectory = $MakeDirectory;
160			return $this;
161			}
162
163			/**
164			* @return array
165			*/
166			public function getRequires(): array
167			{
168			return $this->Requires;
169			}
170
171			/**
172			* @param array $Requires
173			* @return Path
174			*/
175			public function setRequires(array $Requires): Path
176			{
177			$this->Requires = $Requires;
178			return $this;
179			}
180
181			/**
182			* @return array
183			*/
184			public function getRequiresMountsFor(): array
185			{
186			return $this->RequiresMountsFor;
187			}
188
189			/**
190			* @param array $RequiresMountsFor
191			* @return Path
192			*/
193			public function setRequiresMountsFor(array $RequiresMountsFor): Path
194			{
195			$this->RequiresMountsFor = $RequiresMountsFor;
196			return $this;
197			}
198
199			/**
200			* @return mixed
201			*/
202			public function getResult()
203			{
204			return $this->Result;
205			}
206
207			/**
208			* @param mixed $Result
209			* @return Path
210			*/
211			public function setResult($Result)
212			{
213			$this->Result = $Result;
214			return $this;
215			}
216
217			/**
218			* @return array
219			*/
220			public function getTriggers(): array
221			{
222			return $this->Triggers;
223			}
224
225			/**
226			* @param array $Triggers
227			* @return Path
228			*/
229			public function setTriggers(array $Triggers): Path
230			{
231			$this->Triggers = $Triggers;
232			return $this;
233			}
234
235			/**
236			* @return mixed
237			*/
238			public function getUnit()
239			{
240			return $this->Unit;
241			}
242
243			/**
244			* @param mixed $Unit
245			* @return Path
246			*/
247			public function setUnit($Unit)
248			{
249			$this->Unit = $Unit;
250			return $this;
251			}
252
253			/**
254			* @return mixed
255			*/
256			public function getUnitFilePreset()
257			{
258			return $this->UnitFilePreset;
259			}
260
261			/**
262			* @param mixed $UnitFilePreset
263			* @return Path
264			*/
265			public function setUnitFilePreset($UnitFilePreset)
266			{
267			$this->UnitFilePreset = $UnitFilePreset;
268			return $this;
269			}
270
271			/**
272			* @return mixed
273			*/
274			public function getUnitFileState()
275			{
276			return $this->UnitFileState;
277			}
278
279			/**
280			* @param mixed $UnitFileState
281			* @return Path
282			*/
283			public function setUnitFileState($UnitFileState)
284			{
285			$this->UnitFileState = $UnitFileState;
286			return $this;
287			}
288
289			/**
290			* @return array
291			*/
292			public function getWantedBy(): array
293			{
294			return $this->WantedBy;
295			}
296
297			/**
298			* @param array $WantedBy
299			* @return Path
300			*/
301			public function setWantedBy(array $WantedBy): Path
302			{
303			$this->WantedBy = $WantedBy;
304			return $this;
305			}
306			}
307

CyberLine / systemd-state

Push — master ( c21b15...51d90f )

Path::setRequires() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like