AbstractType::getAssertTimestampMonotonic() - Code Metrics - Inspection of "- more examples" - CyberLine/systemd-state - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 172ef2...431705 )

by Alexander

created 2019-01-30 12:30 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 $StartLimitInterval;

    /** @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 getStartLimitInterval(): int
    {
        return $this->StartLimitInterval;
    }

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

CyberLine / systemd-state

Push — master ( 172ef2...431705 )

AbstractType::getAssertTimestampMonotonic() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like