AbstractType::getAssertTimestampMonotonic() - 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

AbstractType::getAssertTimestampMonotonic() A

↳ Parent: AbstractType

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace CyberLine\SystemdState\Types;

abstract class AbstractType implements \JsonSerializable
{
    /** @var \DateTimeImmutable */
    protected $ActiveEnterTimestamp;

    /** @var integer */
    protected $ActiveEnterTimestampMonotonic;

    /** @var integer */
    protected $ActiveExitTimestampMonotonic;

    /**
     * @var string
     */
    protected $ActiveState;

    /**
     * @var boolean
     */
    protected $AllowIsolate;

    /**
     * @var boolean
     */
    protected $AssertResult;

    /** @var \DateTimeImmutable */
    protected $AssertTimestamp;

    /** @var integer */
    protected $AssertTimestampMonotonic;

    /** @var array */
    protected $Before = [];

    /** @var boolean */
    protected $CanIsolate;

    /** @var boolean */
    protected $CanReload;

    /** @var boolean */
    protected $CanStart;

    /** @var boolean */
    protected $CanStop;

    /** @var boolean */
    protected $ConditionResult;

    /** @var \DateTimeImmutable */
    protected $ConditionTimestamp;

    /** @var integer */
    protected $ConditionTimestampMonotonic;

    /** @var boolean */
    protected $DefaultDependencies;

    /** @var string */
    protected $Description;

    /** @var string */
    protected $Id;

    /** @var boolean */
    protected $IgnoreOnIsolate;

    /** @var integer */
    protected $InactiveEnterTimestampMonotonic;

    /** @var \DateTimeImmutable */
    protected $InactiveExitTimestamp;

    /**
     * @var integer
     */
    protected $InactiveExitTimestampMonotonic;

    /** @var string */
    protected $InvocationID;

    /** @var string */
    protected $JobTimeoutAction;

    /** @var string */
    protected $JobTimeoutUSec;

    /** @var string */
    protected $LoadError;

    /** @var string */
    protected $LoadState;

    /** @var array */
    protected $Names = [];

    /** @var boolean */
    protected $NeedDaemonReload;

    /** @var string */
    protected $OnFailureJobMode;

    /** @var boolean */
    protected $Perpetual;

    /** @var boolean */
    protected $RefuseManualStart;

    /** @var boolean */
    protected $RefuseManualStop;

    /** @var string */
    protected $StartLimitAction;

    /** @var boolean */
    protected $StartLimitBurst;

    /** @var integer */
    protected $StartLimitIntervalSec;

    /** @var \DateTimeImmutable */
    protected $StateChangeTimestamp;

    /** @var integer */
    protected $StateChangeTimestampMonotonic;

    /** @var boolean */
    protected $StopWhenUnneeded;

    /** @var string */
    protected $SubState;

    /** @var boolean */
    protected $Transient;

    /**
     * @return \DateTimeImmutable
     */
    public function getActiveEnterTimestamp(): \DateTimeImmutable
    {
        return $this->ActiveEnterTimestamp;
    }

    /**
     * @param \DateTimeImmutable $ActiveEnterTimestamp
     * @return AbstractType
     */
    public function setActiveEnterTimestamp(\DateTimeImmutable $ActiveEnterTimestamp): AbstractType
    {
        $this->ActiveEnterTimestamp = $ActiveEnterTimestamp;
        return $this;
    }

    /**
     * @return int
     */
    public function getActiveEnterTimestampMonotonic(): int
    {
        return $this->ActiveEnterTimestampMonotonic;
    }

    /**
     * @param int $ActiveEnterTimestampMonotonic
     * @return AbstractType
     */
    public function setActiveEnterTimestampMonotonic(int $ActiveEnterTimestampMonotonic): AbstractType
    {
        $this->ActiveEnterTimestampMonotonic = $ActiveEnterTimestampMonotonic;
        return $this;
    }

    /**
     * @return int
     */
    public function getActiveExitTimestampMonotonic(): int
    {
        return $this->ActiveExitTimestampMonotonic;
    }

    /**
     * @param int $ActiveExitTimestampMonotonic
     * @return AbstractType
     */
    public function setActiveExitTimestampMonotonic(int $ActiveExitTimestampMonotonic): AbstractType
    {
        $this->ActiveExitTimestampMonotonic = $ActiveExitTimestampMonotonic;
        return $this;
    }

    /**
     * @return string
     */
    public function getActiveState(): string
    {
        return $this->ActiveState;
    }

    /**
     * @param string $ActiveState
     * @return AbstractType
     */
    public function setActiveState(string $ActiveState): AbstractType
    {
        $this->ActiveState = $ActiveState;
        return $this;
    }

    /**
     * @return bool
     */
    public function isAllowIsolate(): bool
    {
        return $this->AllowIsolate;
    }

    /**
     * @param bool $AllowIsolate
     * @return AbstractType
     */
    public function setAllowIsolate(bool $AllowIsolate): AbstractType
    {
        $this->AllowIsolate = $AllowIsolate;
        return $this;
    }

    /**
     * @return bool
     */
    public function isAssertResult(): bool
    {
        return $this->AssertResult;
    }

    /**
     * @param bool $AssertResult
     * @return AbstractType
     */
    public function setAssertResult(bool $AssertResult): AbstractType
    {
        $this->AssertResult = $AssertResult;
        return $this;
    }

    /**
     * @return \DateTimeImmutable
     */
    public function getAssertTimestamp(): \DateTimeImmutable
    {
        return $this->AssertTimestamp;
    }

    /**
     * @param \DateTimeImmutable $AssertTimestamp
     * @return AbstractType
     */
    public function setAssertTimestamp(\DateTimeImmutable $AssertTimestamp): AbstractType
    {
        $this->AssertTimestamp = $AssertTimestamp;
        return $this;
    }

    /**
     * @return int
     */
    public function getAssertTimestampMonotonic(): int
    {
        return $this->AssertTimestampMonotonic;
    }

    /**
     * @param int $AssertTimestampMonotonic
     * @return AbstractType
     */
    public function setAssertTimestampMonotonic(int $AssertTimestampMonotonic): AbstractType
    {
        $this->AssertTimestampMonotonic = $AssertTimestampMonotonic;
        return $this;
    }

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

    /**
     * @param array $Before
     * @return AbstractType
     */
    public function setBefore(array $Before): AbstractType
    {
        $this->Before = $Before;
        return $this;
    }

    /**
     * @return bool
     */
    public function isCanIsolate(): bool
    {
        return $this->CanIsolate;
    }

    /**
     * @param bool $CanIsolate
     * @return AbstractType
     */
    public function setCanIsolate(bool $CanIsolate): AbstractType
    {
        $this->CanIsolate = $CanIsolate;
        return $this;
    }

    /**
     * @return bool
     */
    public function isCanReload(): bool
    {
        return $this->CanReload;
    }

    /**
     * @param bool $CanReload
     * @return AbstractType
     */
    public function setCanReload(bool $CanReload): AbstractType
    {
        $this->CanReload = $CanReload;
        return $this;
    }

    /**
     * @return bool
     */
    public function isCanStart(): bool
    {
        return $this->CanStart;
    }

    /**
     * @param bool $CanStart
     * @return AbstractType
     */
    public function setCanStart(bool $CanStart): AbstractType
    {
        $this->CanStart = $CanStart;
        return $this;
    }

    /**
     * @return bool
     */
    public function isCanStop(): bool
    {
        return $this->CanStop;
    }

    /**
     * @param bool $CanStop
     * @return AbstractType
     */
    public function setCanStop(bool $CanStop): AbstractType
    {
        $this->CanStop = $CanStop;
        return $this;
    }

    /**
     * @return bool
     */
    public function isConditionResult(): bool
    {
        return $this->ConditionResult;
    }

    /**
     * @param bool $ConditionResult
     * @return AbstractType
     */
    public function setConditionResult(bool $ConditionResult): AbstractType
    {
        $this->ConditionResult = $ConditionResult;
        return $this;
    }

    /**
     * @return \DateTimeImmutable
     */
    public function getConditionTimestamp(): \DateTimeImmutable
    {
        return $this->ConditionTimestamp;
    }

    /**
     * @param \DateTimeImmutable $ConditionTimestamp
     * @return AbstractType
     */
    public function setConditionTimestamp(\DateTimeImmutable $ConditionTimestamp): AbstractType
    {
        $this->ConditionTimestamp = $ConditionTimestamp;
        return $this;
    }

    /**
     * @return int
     */
    public function getConditionTimestampMonotonic(): int
    {
        return $this->ConditionTimestampMonotonic;
    }

    /**
     * @param int $ConditionTimestampMonotonic
     * @return AbstractType
     */
    public function setConditionTimestampMonotonic(int $ConditionTimestampMonotonic): AbstractType
    {
        $this->ConditionTimestampMonotonic = $ConditionTimestampMonotonic;
        return $this;
    }

    /**
     * @return bool
     */
    public function isDefaultDependencies(): bool
    {
        return $this->DefaultDependencies;
    }

    /**
     * @param bool $DefaultDependencies
     * @return AbstractType
     */
    public function setDefaultDependencies(bool $DefaultDependencies): AbstractType
    {
        $this->DefaultDependencies = $DefaultDependencies;
        return $this;
    }

    /**
     * @return string
     */
    public function getDescription(): string
    {
        return $this->Description;
    }

    /**
     * @param string $Description
     * @return AbstractType
     */
    public function setDescription(string $Description): AbstractType
    {
        $this->Description = $Description;
        return $this;
    }

    /**
     * @return string
     */
    public function getId(): string
    {
        return $this->Id;
    }

    /**
     * @param string $Id
     * @return AbstractType
     */
    public function setId(string $Id): AbstractType
    {
        $this->Id = $Id;
        return $this;
    }

    /**
     * @return bool
     */
    public function isIgnoreOnIsolate(): bool
    {
        return $this->IgnoreOnIsolate;
    }

    /**
     * @param bool $IgnoreOnIsolate
     * @return AbstractType
     */
    public function setIgnoreOnIsolate(bool $IgnoreOnIsolate): AbstractType
    {
        $this->IgnoreOnIsolate = $IgnoreOnIsolate;
        return $this;
    }

    /**
     * @return int
     */
    public function getInactiveEnterTimestampMonotonic(): int
    {
        return $this->InactiveEnterTimestampMonotonic;
    }

    /**
     * @param int $InactiveEnterTimestampMonotonic
     * @return AbstractType
     */
    public function setInactiveEnterTimestampMonotonic(int $InactiveEnterTimestampMonotonic): AbstractType
    {
        $this->InactiveEnterTimestampMonotonic = $InactiveEnterTimestampMonotonic;
        return $this;
    }

    /**
     * @return \DateTimeImmutable
     */
    public function getInactiveExitTimestamp(): \DateTimeImmutable
    {
        return $this->InactiveExitTimestamp;
    }

    /**
     * @param \DateTimeImmutable $InactiveExitTimestamp
     * @return AbstractType
     */
    public function setInactiveExitTimestamp(\DateTimeImmutable $InactiveExitTimestamp): AbstractType
    {
        $this->InactiveExitTimestamp = $InactiveExitTimestamp;
        return $this;
    }

    /**
     * @return int
     */
    public function getInactiveExitTimestampMonotonic(): int
    {
        return $this->InactiveExitTimestampMonotonic;
    }

    /**
     * @param int $InactiveExitTimestampMonotonic
     * @return AbstractType
     */
    public function setInactiveExitTimestampMonotonic(int $InactiveExitTimestampMonotonic): AbstractType
    {
        $this->InactiveExitTimestampMonotonic = $InactiveExitTimestampMonotonic;
        return $this;
    }

    /**
     * @return string
     */
    public function getInvocationID(): string
    {
        return $this->InvocationID;
    }

    /**
     * @param string $InvocationID
     * @return AbstractType
     */
    public function setInvocationID(string $InvocationID): AbstractType
    {
        $this->InvocationID = $InvocationID;
        return $this;
    }

    /**
     * @return string
     */
    public function getJobTimeoutAction(): string
    {
        return $this->JobTimeoutAction;
    }

    /**
     * @param string $JobTimeoutAction
     * @return AbstractType
     */
    public function setJobTimeoutAction(string $JobTimeoutAction): AbstractType
    {
        $this->JobTimeoutAction = $JobTimeoutAction;
        return $this;
    }

    /**
     * @return string
     */
    public function getJobTimeoutUSec(): string
    {
        return $this->JobTimeoutUSec;
    }

    /**
     * @param string $JobTimeoutUSec
     * @return AbstractType
     */
    public function setJobTimeoutUSec(string $JobTimeoutUSec): AbstractType
    {
        $this->JobTimeoutUSec = $JobTimeoutUSec;
        return $this;
    }

    /**
     * @return string
     */
    public function getLoadError(): string
    {
        return $this->LoadError;
    }

    /**
     * @param string $LoadError
     * @return AbstractType
     */
    public function setLoadError(string $LoadError): AbstractType
    {
        $this->LoadError = $LoadError;
        return $this;
    }

    /**
     * @return string
     */
    public function getLoadState(): string
    {
        return $this->LoadState;
    }

    /**
     * @param string $LoadState
     * @return AbstractType
     */
    public function setLoadState(string $LoadState): AbstractType
    {
        $this->LoadState = $LoadState;
        return $this;
    }

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

    /**
     * @param array $Names
     * @return AbstractType
     */
    public function setNames(array $Names): AbstractType
    {
        $this->Names = $Names;
        return $this;
    }

    /**
     * @return bool
     */
    public function isNeedDaemonReload(): bool
    {
        return $this->NeedDaemonReload;
    }

    /**
     * @param bool $NeedDaemonReload
     * @return AbstractType
     */
    public function setNeedDaemonReload(bool $NeedDaemonReload): AbstractType
    {
        $this->NeedDaemonReload = $NeedDaemonReload;
        return $this;
    }

    /**
     * @return string
     */
    public function getOnFailureJobMode(): string
    {
        return $this->OnFailureJobMode;
    }

    /**
     * @param string $OnFailureJobMode
     * @return AbstractType
     */
    public function setOnFailureJobMode(string $OnFailureJobMode): AbstractType
    {
        $this->OnFailureJobMode = $OnFailureJobMode;
        return $this;
    }

    /**
     * @return bool
     */
    public function isPerpetual(): bool
    {
        return $this->Perpetual;
    }

    /**
     * @param bool $Perpetual
     * @return AbstractType
     */
    public function setPerpetual(bool $Perpetual): AbstractType
    {
        $this->Perpetual = $Perpetual;
        return $this;
    }

    /**
     * @return bool
     */
    public function isRefuseManualStart(): bool
    {
        return $this->RefuseManualStart;
    }

    /**
     * @param bool $RefuseManualStart
     * @return AbstractType
     */
    public function setRefuseManualStart(bool $RefuseManualStart): AbstractType
    {
        $this->RefuseManualStart = $RefuseManualStart;
        return $this;
    }

    /**
     * @return bool
     */
    public function isRefuseManualStop(): bool
    {
        return $this->RefuseManualStop;
    }

    /**
     * @param bool $RefuseManualStop
     * @return AbstractType
     */
    public function setRefuseManualStop(bool $RefuseManualStop): AbstractType
    {
        $this->RefuseManualStop = $RefuseManualStop;
        return $this;
    }

    /**
     * @return string
     */
    public function getStartLimitAction(): string
    {
        return $this->StartLimitAction;
    }

    /**
     * @param string $StartLimitAction
     * @return AbstractType
     */
    public function setStartLimitAction(string $StartLimitAction): AbstractType
    {
        $this->StartLimitAction = $StartLimitAction;
        return $this;
    }

    /**
     * @return bool
     */
    public function isStartLimitBurst(): bool
    {
        return $this->StartLimitBurst;
    }

    /**
     * @param bool $StartLimitBurst
     * @return AbstractType
     */
    public function setStartLimitBurst(bool $StartLimitBurst): AbstractType
    {
        $this->StartLimitBurst = $StartLimitBurst;
        return $this;
    }

    /**
     * @return int
     */
    public function getStartLimitIntervalSec(): int
    {
        return $this->StartLimitIntervalSec;
    }

    /**
     * @param int $StartLimitIntervalSec
     * @return AbstractType
     */
    public function setStartLimitIntervalSec(int $StartLimitIntervalSec): AbstractType
    {
        $this->StartLimitIntervalSec = $StartLimitIntervalSec;
        return $this;
    }

    /**
     * @return \DateTimeImmutable
     */
    public function getStateChangeTimestamp(): \DateTimeImmutable
    {
        return $this->StateChangeTimestamp;
    }

    /**
     * @param \DateTimeImmutable $StateChangeTimestamp
     * @return AbstractType
     */
    public function setStateChangeTimestamp(\DateTimeImmutable $StateChangeTimestamp): AbstractType
    {
        $this->StateChangeTimestamp = $StateChangeTimestamp;
        return $this;
    }

    /**
     * @return int
     */
    public function getStateChangeTimestampMonotonic(): int
    {
        return $this->StateChangeTimestampMonotonic;
    }

    /**
     * @param int $StateChangeTimestampMonotonic
     * @return AbstractType
     */
    public function setStateChangeTimestampMonotonic(int $StateChangeTimestampMonotonic): AbstractType
    {
        $this->StateChangeTimestampMonotonic = $StateChangeTimestampMonotonic;
        return $this;
    }

    /**
     * @return bool
     */
    public function isStopWhenUnneeded(): bool
    {
        return $this->StopWhenUnneeded;
    }

    /**
     * @param bool $StopWhenUnneeded
     * @return AbstractType
     */
    public function setStopWhenUnneeded(bool $StopWhenUnneeded): AbstractType
    {
        $this->StopWhenUnneeded = $StopWhenUnneeded;
        return $this;
    }

    /**
     * @return string
     */
    public function getSubState(): string
    {
        return $this->SubState;
    }

    /**
     * @param string $SubState
     * @return AbstractType
     */
    public function setSubState(string $SubState): AbstractType
    {
        $this->SubState = $SubState;
        return $this;
    }

    /**
     * @return bool
     */
    public function isTransient(): bool
    {
        return $this->Transient;
    }

    /**
     * @param bool $Transient
     * @return AbstractType
     */
    public function setTransient(bool $Transient): AbstractType
    {
        $this->Transient = $Transient;
        return $this;
    }

    public function jsonSerialize()
    {
        return get_object_vars($this);
    }
}


1			<?php
2
3			namespace CyberLine\SystemdState\Types;
4
5			abstract class AbstractType implements \JsonSerializable
6			{
7			/** @var \DateTimeImmutable */
8			protected $ActiveEnterTimestamp;
9
10			/** @var integer */
11			protected $ActiveEnterTimestampMonotonic;
12
13			/** @var integer */
14			protected $ActiveExitTimestampMonotonic;
15
16			/**
17			* @var string
18			*/
19			protected $ActiveState;
20
21			/**
22			* @var boolean
23			*/
24			protected $AllowIsolate;
25
26			/**
27			* @var boolean
28			*/
29			protected $AssertResult;
30
31			/** @var \DateTimeImmutable */
32			protected $AssertTimestamp;
33
34			/** @var integer */
35			protected $AssertTimestampMonotonic;
36
37			/** @var array */
38			protected $Before = [];
39
40			/** @var boolean */
41			protected $CanIsolate;
42
43			/** @var boolean */
44			protected $CanReload;
45
46			/** @var boolean */
47			protected $CanStart;
48
49			/** @var boolean */
50			protected $CanStop;
51
52			/** @var boolean */
53			protected $ConditionResult;
54
55			/** @var \DateTimeImmutable */
56			protected $ConditionTimestamp;
57
58			/** @var integer */
59			protected $ConditionTimestampMonotonic;
60
61			/** @var boolean */
62			protected $DefaultDependencies;
63
64			/** @var string */
65			protected $Description;
66
67			/** @var string */
68			protected $Id;
69
70			/** @var boolean */
71			protected $IgnoreOnIsolate;
72
73			/** @var integer */
74			protected $InactiveEnterTimestampMonotonic;
75
76			/** @var \DateTimeImmutable */
77			protected $InactiveExitTimestamp;
78
79			/**
80			* @var integer
81			*/
82			protected $InactiveExitTimestampMonotonic;
83
84			/** @var string */
85			protected $InvocationID;
86
87			/** @var string */
88			protected $JobTimeoutAction;
89
90			/** @var string */
91			protected $JobTimeoutUSec;
92
93			/** @var string */
94			protected $LoadError;
95
96			/** @var string */
97			protected $LoadState;
98
99			/** @var array */
100			protected $Names = [];
101
102			/** @var boolean */
103			protected $NeedDaemonReload;
104
105			/** @var string */
106			protected $OnFailureJobMode;
107
108			/** @var boolean */
109			protected $Perpetual;
110
111			/** @var boolean */
112			protected $RefuseManualStart;
113
114			/** @var boolean */
115			protected $RefuseManualStop;
116
117			/** @var string */
118			protected $StartLimitAction;
119
120			/** @var boolean */
121			protected $StartLimitBurst;
122
123			/** @var integer */
124			protected $StartLimitIntervalSec;
125
126			/** @var \DateTimeImmutable */
127			protected $StateChangeTimestamp;
128
129			/** @var integer */
130			protected $StateChangeTimestampMonotonic;
131
132			/** @var boolean */
133			protected $StopWhenUnneeded;
134
135			/** @var string */
136			protected $SubState;
137
138			/** @var boolean */
139			protected $Transient;
140
141			/**
142			* @return \DateTimeImmutable
143			*/
144			public function getActiveEnterTimestamp(): \DateTimeImmutable
145			{
146			return $this->ActiveEnterTimestamp;
147			}
148
149			/**
150			* @param \DateTimeImmutable $ActiveEnterTimestamp
151			* @return AbstractType
152			*/
153			public function setActiveEnterTimestamp(\DateTimeImmutable $ActiveEnterTimestamp): AbstractType
154			{
155			$this->ActiveEnterTimestamp = $ActiveEnterTimestamp;
156			return $this;
157			}
158
159			/**
160			* @return int
161			*/
162			public function getActiveEnterTimestampMonotonic(): int
163			{
164			return $this->ActiveEnterTimestampMonotonic;
165			}
166
167			/**
168			* @param int $ActiveEnterTimestampMonotonic
169			* @return AbstractType
170			*/
171			public function setActiveEnterTimestampMonotonic(int $ActiveEnterTimestampMonotonic): AbstractType
172			{
173			$this->ActiveEnterTimestampMonotonic = $ActiveEnterTimestampMonotonic;
174			return $this;
175			}
176
177			/**
178			* @return int
179			*/
180			public function getActiveExitTimestampMonotonic(): int
181			{
182			return $this->ActiveExitTimestampMonotonic;
183			}
184
185			/**
186			* @param int $ActiveExitTimestampMonotonic
187			* @return AbstractType
188			*/
189			public function setActiveExitTimestampMonotonic(int $ActiveExitTimestampMonotonic): AbstractType
190			{
191			$this->ActiveExitTimestampMonotonic = $ActiveExitTimestampMonotonic;
192			return $this;
193			}
194
195			/**
196			* @return string
197			*/
198			public function getActiveState(): string
199			{
200			return $this->ActiveState;
201			}
202
203			/**
204			* @param string $ActiveState
205			* @return AbstractType
206			*/
207			public function setActiveState(string $ActiveState): AbstractType
208			{
209			$this->ActiveState = $ActiveState;
210			return $this;
211			}
212
213			/**
214			* @return bool
215			*/
216			public function isAllowIsolate(): bool
217			{
218			return $this->AllowIsolate;
219			}
220
221			/**
222			* @param bool $AllowIsolate
223			* @return AbstractType
224			*/
225			public function setAllowIsolate(bool $AllowIsolate): AbstractType
226			{
227			$this->AllowIsolate = $AllowIsolate;
228			return $this;
229			}
230
231			/**
232			* @return bool
233			*/
234			public function isAssertResult(): bool
235			{
236			return $this->AssertResult;
237			}
238
239			/**
240			* @param bool $AssertResult
241			* @return AbstractType
242			*/
243			public function setAssertResult(bool $AssertResult): AbstractType
244			{
245			$this->AssertResult = $AssertResult;
246			return $this;
247			}
248
249			/**
250			* @return \DateTimeImmutable
251			*/
252			public function getAssertTimestamp(): \DateTimeImmutable
253			{
254			return $this->AssertTimestamp;
255			}
256
257			/**
258			* @param \DateTimeImmutable $AssertTimestamp
259			* @return AbstractType
260			*/
261			public function setAssertTimestamp(\DateTimeImmutable $AssertTimestamp): AbstractType
262			{
263			$this->AssertTimestamp = $AssertTimestamp;
264			return $this;
265			}
266
267			/**
268			* @return int
269			*/
270			public function getAssertTimestampMonotonic(): int
271			{
272			return $this->AssertTimestampMonotonic;
273			}
274
275			/**
276			* @param int $AssertTimestampMonotonic
277			* @return AbstractType
278			*/
279			public function setAssertTimestampMonotonic(int $AssertTimestampMonotonic): AbstractType
280			{
281			$this->AssertTimestampMonotonic = $AssertTimestampMonotonic;
282			return $this;
283			}
284
285			/**
286			* @return array
287			*/
288			public function getBefore(): array
289			{
290			return $this->Before;
291			}
292
293			/**
294			* @param array $Before
295			* @return AbstractType
296			*/
297			public function setBefore(array $Before): AbstractType
298			{
299			$this->Before = $Before;
300			return $this;
301			}
302
303			/**
304			* @return bool
305			*/
306			public function isCanIsolate(): bool
307			{
308			return $this->CanIsolate;
309			}
310
311			/**
312			* @param bool $CanIsolate
313			* @return AbstractType
314			*/
315			public function setCanIsolate(bool $CanIsolate): AbstractType
316			{
317			$this->CanIsolate = $CanIsolate;
318			return $this;
319			}
320
321			/**
322			* @return bool
323			*/
324			public function isCanReload(): bool
325			{
326			return $this->CanReload;
327			}
328
329			/**
330			* @param bool $CanReload
331			* @return AbstractType
332			*/
333			public function setCanReload(bool $CanReload): AbstractType
334			{
335			$this->CanReload = $CanReload;
336			return $this;
337			}
338
339			/**
340			* @return bool
341			*/
342			public function isCanStart(): bool
343			{
344			return $this->CanStart;
345			}
346
347			/**
348			* @param bool $CanStart
349			* @return AbstractType
350			*/
351			public function setCanStart(bool $CanStart): AbstractType
352			{
353			$this->CanStart = $CanStart;
354			return $this;
355			}
356
357			/**
358			* @return bool
359			*/
360			public function isCanStop(): bool
361			{
362			return $this->CanStop;
363			}
364
365			/**
366			* @param bool $CanStop
367			* @return AbstractType
368			*/
369			public function setCanStop(bool $CanStop): AbstractType
370			{
371			$this->CanStop = $CanStop;
372			return $this;
373			}
374
375			/**
376			* @return bool
377			*/
378			public function isConditionResult(): bool
379			{
380			return $this->ConditionResult;
381			}
382
383			/**
384			* @param bool $ConditionResult
385			* @return AbstractType
386			*/
387			public function setConditionResult(bool $ConditionResult): AbstractType
388			{
389			$this->ConditionResult = $ConditionResult;
390			return $this;
391			}
392
393			/**
394			* @return \DateTimeImmutable
395			*/
396			public function getConditionTimestamp(): \DateTimeImmutable
397			{
398			return $this->ConditionTimestamp;
399			}
400
401			/**
402			* @param \DateTimeImmutable $ConditionTimestamp
403			* @return AbstractType
404			*/
405			public function setConditionTimestamp(\DateTimeImmutable $ConditionTimestamp): AbstractType
406			{
407			$this->ConditionTimestamp = $ConditionTimestamp;
408			return $this;
409			}
410
411			/**
412			* @return int
413			*/
414			public function getConditionTimestampMonotonic(): int
415			{
416			return $this->ConditionTimestampMonotonic;
417			}
418
419			/**
420			* @param int $ConditionTimestampMonotonic
421			* @return AbstractType
422			*/
423			public function setConditionTimestampMonotonic(int $ConditionTimestampMonotonic): AbstractType
424			{
425			$this->ConditionTimestampMonotonic = $ConditionTimestampMonotonic;
426			return $this;
427			}
428
429			/**
430			* @return bool
431			*/
432			public function isDefaultDependencies(): bool
433			{
434			return $this->DefaultDependencies;
435			}
436
437			/**
438			* @param bool $DefaultDependencies
439			* @return AbstractType
440			*/
441			public function setDefaultDependencies(bool $DefaultDependencies): AbstractType
442			{
443			$this->DefaultDependencies = $DefaultDependencies;
444			return $this;
445			}
446
447			/**
448			* @return string
449			*/
450			public function getDescription(): string
451			{
452			return $this->Description;
453			}
454
455			/**
456			* @param string $Description
457			* @return AbstractType
458			*/
459			public function setDescription(string $Description): AbstractType
460			{
461			$this->Description = $Description;
462			return $this;
463			}
464
465			/**
466			* @return string
467			*/
468			public function getId(): string
469			{
470			return $this->Id;
471			}
472
473			/**
474			* @param string $Id
475			* @return AbstractType
476			*/
477			public function setId(string $Id): AbstractType
478			{
479			$this->Id = $Id;
480			return $this;
481			}
482
483			/**
484			* @return bool
485			*/
486			public function isIgnoreOnIsolate(): bool
487			{
488			return $this->IgnoreOnIsolate;
489			}
490
491			/**
492			* @param bool $IgnoreOnIsolate
493			* @return AbstractType
494			*/
495			public function setIgnoreOnIsolate(bool $IgnoreOnIsolate): AbstractType
496			{
497			$this->IgnoreOnIsolate = $IgnoreOnIsolate;
498			return $this;
499			}
500
501			/**
502			* @return int
503			*/
504			public function getInactiveEnterTimestampMonotonic(): int
505			{
506			return $this->InactiveEnterTimestampMonotonic;
507			}
508
509			/**
510			* @param int $InactiveEnterTimestampMonotonic
511			* @return AbstractType
512			*/
513			public function setInactiveEnterTimestampMonotonic(int $InactiveEnterTimestampMonotonic): AbstractType
514			{
515			$this->InactiveEnterTimestampMonotonic = $InactiveEnterTimestampMonotonic;
516			return $this;
517			}
518
519			/**
520			* @return \DateTimeImmutable
521			*/
522			public function getInactiveExitTimestamp(): \DateTimeImmutable
523			{
524			return $this->InactiveExitTimestamp;
525			}
526
527			/**
528			* @param \DateTimeImmutable $InactiveExitTimestamp
529			* @return AbstractType
530			*/
531			public function setInactiveExitTimestamp(\DateTimeImmutable $InactiveExitTimestamp): AbstractType
532			{
533			$this->InactiveExitTimestamp = $InactiveExitTimestamp;
534			return $this;
535			}
536
537			/**
538			* @return int
539			*/
540			public function getInactiveExitTimestampMonotonic(): int
541			{
542			return $this->InactiveExitTimestampMonotonic;
543			}
544
545			/**
546			* @param int $InactiveExitTimestampMonotonic
547			* @return AbstractType
548			*/
549			public function setInactiveExitTimestampMonotonic(int $InactiveExitTimestampMonotonic): AbstractType
550			{
551			$this->InactiveExitTimestampMonotonic = $InactiveExitTimestampMonotonic;
552			return $this;
553			}
554
555			/**
556			* @return string
557			*/
558			public function getInvocationID(): string
559			{
560			return $this->InvocationID;
561			}
562
563			/**
564			* @param string $InvocationID
565			* @return AbstractType
566			*/
567			public function setInvocationID(string $InvocationID): AbstractType
568			{
569			$this->InvocationID = $InvocationID;
570			return $this;
571			}
572
573			/**
574			* @return string
575			*/
576			public function getJobTimeoutAction(): string
577			{
578			return $this->JobTimeoutAction;
579			}
580
581			/**
582			* @param string $JobTimeoutAction
583			* @return AbstractType
584			*/
585			public function setJobTimeoutAction(string $JobTimeoutAction): AbstractType
586			{
587			$this->JobTimeoutAction = $JobTimeoutAction;
588			return $this;
589			}
590
591			/**
592			* @return string
593			*/
594			public function getJobTimeoutUSec(): string
595			{
596			return $this->JobTimeoutUSec;
597			}
598
599			/**
600			* @param string $JobTimeoutUSec
601			* @return AbstractType
602			*/
603			public function setJobTimeoutUSec(string $JobTimeoutUSec): AbstractType
604			{
605			$this->JobTimeoutUSec = $JobTimeoutUSec;
606			return $this;
607			}
608
609			/**
610			* @return string
611			*/
612			public function getLoadError(): string
613			{
614			return $this->LoadError;
615			}
616
617			/**
618			* @param string $LoadError
619			* @return AbstractType
620			*/
621			public function setLoadError(string $LoadError): AbstractType
622			{
623			$this->LoadError = $LoadError;
624			return $this;
625			}
626
627			/**
628			* @return string
629			*/
630			public function getLoadState(): string
631			{
632			return $this->LoadState;
633			}
634
635			/**
636			* @param string $LoadState
637			* @return AbstractType
638			*/
639			public function setLoadState(string $LoadState): AbstractType
640			{
641			$this->LoadState = $LoadState;
642			return $this;
643			}
644
645			/**
646			* @return array
647			*/
648			public function getNames(): array
649			{
650			return $this->Names;
651			}
652
653			/**
654			* @param array $Names
655			* @return AbstractType
656			*/
657			public function setNames(array $Names): AbstractType
658			{
659			$this->Names = $Names;
660			return $this;
661			}
662
663			/**
664			* @return bool
665			*/
666			public function isNeedDaemonReload(): bool
667			{
668			return $this->NeedDaemonReload;
669			}
670
671			/**
672			* @param bool $NeedDaemonReload
673			* @return AbstractType
674			*/
675			public function setNeedDaemonReload(bool $NeedDaemonReload): AbstractType
676			{
677			$this->NeedDaemonReload = $NeedDaemonReload;
678			return $this;
679			}
680
681			/**
682			* @return string
683			*/
684			public function getOnFailureJobMode(): string
685			{
686			return $this->OnFailureJobMode;
687			}
688
689			/**
690			* @param string $OnFailureJobMode
691			* @return AbstractType
692			*/
693			public function setOnFailureJobMode(string $OnFailureJobMode): AbstractType
694			{
695			$this->OnFailureJobMode = $OnFailureJobMode;
696			return $this;
697			}
698
699			/**
700			* @return bool
701			*/
702			public function isPerpetual(): bool
703			{
704			return $this->Perpetual;
705			}
706
707			/**
708			* @param bool $Perpetual
709			* @return AbstractType
710			*/
711			public function setPerpetual(bool $Perpetual): AbstractType
712			{
713			$this->Perpetual = $Perpetual;
714			return $this;
715			}
716
717			/**
718			* @return bool
719			*/
720			public function isRefuseManualStart(): bool
721			{
722			return $this->RefuseManualStart;
723			}
724
725			/**
726			* @param bool $RefuseManualStart
727			* @return AbstractType
728			*/
729			public function setRefuseManualStart(bool $RefuseManualStart): AbstractType
730			{
731			$this->RefuseManualStart = $RefuseManualStart;
732			return $this;
733			}
734
735			/**
736			* @return bool
737			*/
738			public function isRefuseManualStop(): bool
739			{
740			return $this->RefuseManualStop;
741			}
742
743			/**
744			* @param bool $RefuseManualStop
745			* @return AbstractType
746			*/
747			public function setRefuseManualStop(bool $RefuseManualStop): AbstractType
748			{
749			$this->RefuseManualStop = $RefuseManualStop;
750			return $this;
751			}
752
753			/**
754			* @return string
755			*/
756			public function getStartLimitAction(): string
757			{
758			return $this->StartLimitAction;
759			}
760
761			/**
762			* @param string $StartLimitAction
763			* @return AbstractType
764			*/
765			public function setStartLimitAction(string $StartLimitAction): AbstractType
766			{
767			$this->StartLimitAction = $StartLimitAction;
768			return $this;
769			}
770
771			/**
772			* @return bool
773			*/
774			public function isStartLimitBurst(): bool
775			{
776			return $this->StartLimitBurst;
777			}
778
779			/**
780			* @param bool $StartLimitBurst
781			* @return AbstractType
782			*/
783			public function setStartLimitBurst(bool $StartLimitBurst): AbstractType
784			{
785			$this->StartLimitBurst = $StartLimitBurst;
786			return $this;
787			}
788
789			/**
790			* @return int
791			*/
792			public function getStartLimitIntervalSec(): int
793			{
794			return $this->StartLimitIntervalSec;
795			}
796
797			/**
798			* @param int $StartLimitIntervalSec
799			* @return AbstractType
800			*/
801			public function setStartLimitIntervalSec(int $StartLimitIntervalSec): AbstractType
802			{
803			$this->StartLimitIntervalSec = $StartLimitIntervalSec;
804			return $this;
805			}
806
807			/**
808			* @return \DateTimeImmutable
809			*/
810			public function getStateChangeTimestamp(): \DateTimeImmutable
811			{
812			return $this->StateChangeTimestamp;
813			}
814
815			/**
816			* @param \DateTimeImmutable $StateChangeTimestamp
817			* @return AbstractType
818			*/
819			public function setStateChangeTimestamp(\DateTimeImmutable $StateChangeTimestamp): AbstractType
820			{
821			$this->StateChangeTimestamp = $StateChangeTimestamp;
822			return $this;
823			}
824
825			/**
826			* @return int
827			*/
828			public function getStateChangeTimestampMonotonic(): int
829			{
830			return $this->StateChangeTimestampMonotonic;
831			}
832
833			/**
834			* @param int $StateChangeTimestampMonotonic
835			* @return AbstractType
836			*/
837			public function setStateChangeTimestampMonotonic(int $StateChangeTimestampMonotonic): AbstractType
838			{
839			$this->StateChangeTimestampMonotonic = $StateChangeTimestampMonotonic;
840			return $this;
841			}
842
843			/**
844			* @return bool
845			*/
846			public function isStopWhenUnneeded(): bool
847			{
848			return $this->StopWhenUnneeded;
849			}
850
851			/**
852			* @param bool $StopWhenUnneeded
853			* @return AbstractType
854			*/
855			public function setStopWhenUnneeded(bool $StopWhenUnneeded): AbstractType
856			{
857			$this->StopWhenUnneeded = $StopWhenUnneeded;
858			return $this;
859			}
860
861			/**
862			* @return string
863			*/
864			public function getSubState(): string
865			{
866			return $this->SubState;
867			}
868
869			/**
870			* @param string $SubState
871			* @return AbstractType
872			*/
873			public function setSubState(string $SubState): AbstractType
874			{
875			$this->SubState = $SubState;
876			return $this;
877			}
878
879			/**
880			* @return bool
881			*/
882			public function isTransient(): bool
883			{
884			return $this->Transient;
885			}
886
887			/**
888			* @param bool $Transient
889			* @return AbstractType
890			*/
891			public function setTransient(bool $Transient): AbstractType
892			{
893			$this->Transient = $Transient;
894			return $this;
895			}
896
897			public function jsonSerialize()
898			{
899			return get_object_vars($this);
900			}
901			}
902

CyberLine / systemd-state

Push — master ( c21b15...51d90f )

AbstractType::getAssertTimestampMonotonic() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like