QueueAttributes::fromXML() - Code Metrics - Inspection of "add travis ci badges" - milkmeowo/laravel-queue-aliyun-mns - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (b10c57)

by milkmeowo

created 2018-06-01 08:00 UTC

QueueAttributes::fromXML() D

↳ Parent: Project

Complexity

Conditions	28
Paths	28

Size

Total Lines	130
Code Lines	93

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	28
eloc	93
nc	28
nop	1
dl	0
loc	130
rs	4.4803
c	0
b	0
f	0

How to fix Long Method Complexity

<?php
namespace AliyunMNS\Model;

use AliyunMNS\Constants;

/**
 * Please refer to
 * https://docs.aliyun.com/?spm=#/pub/mns/api_reference/intro&intro
 * for more details
 */
class QueueAttributes
{
    private $delaySeconds;
    private $maximumMessageSize;
    private $messageRetentionPeriod;
    private $visibilityTimeout;
    private $pollingWaitSeconds;
    private $LoggingEnabled;

    # the following attributes cannot be changed
    private $queueName;
    private $createTime;
    private $lastModifyTime;
    private $activeMessages;
    private $inactiveMessages;
    private $delayMessages;

    public function __construct(
        $delaySeconds = NULL,
        $maximumMessageSize = NULL,
        $messageRetentionPeriod = NULL,
        $visibilityTimeout = NULL,
        $pollingWaitSeconds = NULL,
        $queueName = NULL,
        $createTime = NULL,
        $lastModifyTime = NULL,
        $activeMessages = NULL,
        $inactiveMessages = NULL,
        $delayMessages = NULL,
        $LoggingEnabled = NULL)
    {
        $this->delaySeconds = $delaySeconds;
        $this->maximumMessageSize = $maximumMessageSize;
        $this->messageRetentionPeriod = $messageRetentionPeriod;
        $this->visibilityTimeout = $visibilityTimeout;
        $this->pollingWaitSeconds = $pollingWaitSeconds;
        $this->loggingEnabled = $LoggingEnabled;

        $this->queueName = $queueName;
        $this->createTime = $createTime;
        $this->lastModifyTime = $lastModifyTime;
        $this->activeMessages = $activeMessages;
        $this->inactiveMessages = $inactiveMessages;
        $this->delayMessages = $delayMessages;
    }

    public function setDelaySeconds($delaySeconds)
    {
        $this->delaySeconds = $delaySeconds;
    }

    public function getDelaySeconds()
    {
        return $this->delaySeconds;
    }

    public function setLoggingEnabled($loggingEnabled)
    {
        $this->loggingEnabled = $loggingEnabled;
    }

    public function getLoggingEnabled()
    {
        return $this->loggingEnabled;
    }

    public function setMaximumMessageSize($maximumMessageSize)
    {
        $this->maximumMessageSize = $maximumMessageSize;
    }

    public function getMaximumMessageSize()
    {
        return $this->maximumMessageSize;
    }

    public function setMessageRetentionPeriod($messageRetentionPeriod)
    {
        $this->messageRetentionPeriod = $messageRetentionPeriod;
    }

    public function getMessageRetentionPeriod()
    {
        return $this->messageRetentionPeriod;
    }

    public function setVisibilityTimeout($visibilityTimeout)
    {
        $this->visibilityTimeout = $visibilityTimeout;
    }

    public function getVisibilityTimeout()
    {
        return $this->visibilityTimeout;
    }

    public function setPollingWaitSeconds($pollingWaitSeconds)
    {
        $this->pollingWaitSeconds = $pollingWaitSeconds;
    }

    public function getPollingWaitSeconds()
    {
        return $this->pollingWaitSeconds;
    }

    public function getQueueName()
    {
        return $this->queueName;
    }

    public function getCreateTime()
    {
        return $this->createTime;
    }

    public function getLastModifyTime()
    {
        return $this->lastModifyTime;
    }

    public function getActiveMessages()
    {
        return $this->activeMessages;
    }

    public function getInactiveMessages()
    {
        return $this->inactiveMessages;
    }

    public function getDelayMessages()
    {
        return $this->delayMessages;
    }

    public function writeXML(\XMLWriter $xmlWriter)
    {
        if ($this->delaySeconds != NULL)
        {
            $xmlWriter->writeElement(Constants::DELAY_SECONDS, $this->delaySeconds);
        }
        if ($this->maximumMessageSize != NULL)
        {
            $xmlWriter->writeElement(Constants::MAXIMUM_MESSAGE_SIZE, $this->maximumMessageSize);
        }
        if ($this->messageRetentionPeriod != NULL)
        {
            $xmlWriter->writeElement(Constants::MESSAGE_RETENTION_PERIOD, $this->messageRetentionPeriod);
        }
        if ($this->visibilityTimeout != NULL)
        {
            $xmlWriter->writeElement(Constants::VISIBILITY_TIMEOUT, $this->visibilityTimeout);
        }
        if ($this->pollingWaitSeconds != NULL)
        {
            $xmlWriter->writeElement(Constants::POLLING_WAIT_SECONDS, $this->pollingWaitSeconds);
        }
        if ($this->loggingEnabled !== NULL)
        {
            $xmlWriter->writeElement(Constants::LOGGING_ENABLED, $this->loggingEnabled ? "True" : "False");
        }
    }

    static public function fromXML(\XMLReader $xmlReader)
    {
        $delaySeconds = NULL;
        $maximumMessageSize = NULL;
        $messageRetentionPeriod = NULL;
        $visibilityTimeout = NULL;
        $pollingWaitSeconds = NULL;
        $queueName = NULL;
        $createTime = NULL;
        $lastModifyTime = NULL;
        $activeMessages = NULL;
        $inactiveMessages = NULL;
        $delayMessages = NULL;
        $loggingEnabled = NULL;

        while ($xmlReader->read())
        {
            if ($xmlReader->nodeType == \XMLReader::ELEMENT)
            {
                switch ($xmlReader->name) {
                case 'DelaySeconds':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $delaySeconds = $xmlReader->value;
                    }
                    break;
                case 'MaximumMessageSize':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $maximumMessageSize = $xmlReader->value;
                    }
                    break;
                case 'MessageRetentionPeriod':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $messageRetentionPeriod = $xmlReader->value;
                    }
                    break;
                case 'VisibilityTimeout':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $visibilityTimeout = $xmlReader->value;
                    }
                    break;
                case 'PollingWaitSeconds':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $pollingWaitSeconds = $xmlReader->value;
                    }
                    break;
                case 'QueueName':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $queueName = $xmlReader->value;
                    }
                    break;
                case 'CreateTime':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $createTime = $xmlReader->value;
                    }
                    break;
                case 'LastModifyTime':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $lastModifyTime = $xmlReader->value;
                    }
                    break;
                case 'ActiveMessages':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $activeMessages = $xmlReader->value;
                    }
                    break;
                case 'InactiveMessages':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $inactiveMessages = $xmlReader->value;
                    }
                    break;
                case 'DelayMessages':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $delayMessages = $xmlReader->value;
                    }
                    break;
                case 'LoggingEnabled':
                    $xmlReader->read();
                    if ($xmlReader->nodeType == \XMLReader::TEXT)
                    {
                        $loggingEnabled = $xmlReader->value;
                        if ($loggingEnabled == "True")
                        {
                            $loggingEnabled = True;
                        }
                        else
                        {
                            $loggingEnabled = False;
                        }
                    }
                    break;
                }
            }
        }

        $attributes = new QueueAttributes(
            $delaySeconds,
            $maximumMessageSize,
            $messageRetentionPeriod,
            $visibilityTimeout,
            $pollingWaitSeconds,
            $queueName,
            $createTime,
            $lastModifyTime,
            $activeMessages,
            $inactiveMessages,
            $delayMessages,
            $loggingEnabled);
        return $attributes;
    }
}

?>


1			<?php
2			namespace AliyunMNS\Model;
3
4			use AliyunMNS\Constants;
5
6			/**
7			* Please refer to
8			* https://docs.aliyun.com/?spm=#/pub/mns/api_reference/intro&intro
9			* for more details
10			*/
11			class QueueAttributes
12			{
13			private $delaySeconds;
14			private $maximumMessageSize;
15			private $messageRetentionPeriod;
16			private $visibilityTimeout;
17			private $pollingWaitSeconds;
18			private $LoggingEnabled;
19
20			# the following attributes cannot be changed
21			private $queueName;
22			private $createTime;
23			private $lastModifyTime;
24			private $activeMessages;
25			private $inactiveMessages;
26			private $delayMessages;
27
28			public function __construct(
29			$delaySeconds = NULL,
30			$maximumMessageSize = NULL,
31			$messageRetentionPeriod = NULL,
32			$visibilityTimeout = NULL,
33			$pollingWaitSeconds = NULL,
34			$queueName = NULL,
35			$createTime = NULL,
36			$lastModifyTime = NULL,
37			$activeMessages = NULL,
38			$inactiveMessages = NULL,
39			$delayMessages = NULL,
40			$LoggingEnabled = NULL)
41			{
42			$this->delaySeconds = $delaySeconds;
43			$this->maximumMessageSize = $maximumMessageSize;
44			$this->messageRetentionPeriod = $messageRetentionPeriod;
45			$this->visibilityTimeout = $visibilityTimeout;
46			$this->pollingWaitSeconds = $pollingWaitSeconds;
47			$this->loggingEnabled = $LoggingEnabled;
48
49			$this->queueName = $queueName;
50			$this->createTime = $createTime;
51			$this->lastModifyTime = $lastModifyTime;
52			$this->activeMessages = $activeMessages;
53			$this->inactiveMessages = $inactiveMessages;
54			$this->delayMessages = $delayMessages;
55			}
56
57			public function setDelaySeconds($delaySeconds)
58			{
59			$this->delaySeconds = $delaySeconds;
60			}
61
62			public function getDelaySeconds()
63			{
64			return $this->delaySeconds;
65			}
66
67			public function setLoggingEnabled($loggingEnabled)
68			{
69			$this->loggingEnabled = $loggingEnabled;
70			}
71
72			public function getLoggingEnabled()
73			{
74			return $this->loggingEnabled;
75			}
76
77			public function setMaximumMessageSize($maximumMessageSize)
78			{
79			$this->maximumMessageSize = $maximumMessageSize;
80			}
81
82			public function getMaximumMessageSize()
83			{
84			return $this->maximumMessageSize;
85			}
86
87			public function setMessageRetentionPeriod($messageRetentionPeriod)
88			{
89			$this->messageRetentionPeriod = $messageRetentionPeriod;
90			}
91
92			public function getMessageRetentionPeriod()
93			{
94			return $this->messageRetentionPeriod;
95			}
96
97			public function setVisibilityTimeout($visibilityTimeout)
98			{
99			$this->visibilityTimeout = $visibilityTimeout;
100			}
101
102			public function getVisibilityTimeout()
103			{
104			return $this->visibilityTimeout;
105			}
106
107			public function setPollingWaitSeconds($pollingWaitSeconds)
108			{
109			$this->pollingWaitSeconds = $pollingWaitSeconds;
110			}
111
112			public function getPollingWaitSeconds()
113			{
114			return $this->pollingWaitSeconds;
115			}
116
117			public function getQueueName()
118			{
119			return $this->queueName;
120			}
121
122			public function getCreateTime()
123			{
124			return $this->createTime;
125			}
126
127			public function getLastModifyTime()
128			{
129			return $this->lastModifyTime;
130			}
131
132			public function getActiveMessages()
133			{
134			return $this->activeMessages;
135			}
136
137			public function getInactiveMessages()
138			{
139			return $this->inactiveMessages;
140			}
141
142			public function getDelayMessages()
143			{
144			return $this->delayMessages;
145			}
146
147			public function writeXML(\XMLWriter $xmlWriter)
148			{
149			if ($this->delaySeconds != NULL)
150			{
151			$xmlWriter->writeElement(Constants::DELAY_SECONDS, $this->delaySeconds);
152			}
153			if ($this->maximumMessageSize != NULL)
154			{
155			$xmlWriter->writeElement(Constants::MAXIMUM_MESSAGE_SIZE, $this->maximumMessageSize);
156			}
157			if ($this->messageRetentionPeriod != NULL)
158			{
159			$xmlWriter->writeElement(Constants::MESSAGE_RETENTION_PERIOD, $this->messageRetentionPeriod);
160			}
161			if ($this->visibilityTimeout != NULL)
162			{
163			$xmlWriter->writeElement(Constants::VISIBILITY_TIMEOUT, $this->visibilityTimeout);
164			}
165			if ($this->pollingWaitSeconds != NULL)
166			{
167			$xmlWriter->writeElement(Constants::POLLING_WAIT_SECONDS, $this->pollingWaitSeconds);
168			}
169			if ($this->loggingEnabled !== NULL)
170			{
171			$xmlWriter->writeElement(Constants::LOGGING_ENABLED, $this->loggingEnabled ? "True" : "False");
172			}
173			}
174
175			static public function fromXML(\XMLReader $xmlReader)
176			{
177			$delaySeconds = NULL;
178			$maximumMessageSize = NULL;
179			$messageRetentionPeriod = NULL;
180			$visibilityTimeout = NULL;
181			$pollingWaitSeconds = NULL;
182			$queueName = NULL;
183			$createTime = NULL;
184			$lastModifyTime = NULL;
185			$activeMessages = NULL;
186			$inactiveMessages = NULL;
187			$delayMessages = NULL;
188			$loggingEnabled = NULL;
189
190			while ($xmlReader->read())
191			{
192			if ($xmlReader->nodeType == \XMLReader::ELEMENT)
193			{
194			switch ($xmlReader->name) {
195			case 'DelaySeconds':
196			$xmlReader->read();
197			if ($xmlReader->nodeType == \XMLReader::TEXT)
198			{
199			$delaySeconds = $xmlReader->value;
200			}
201			break;
202			case 'MaximumMessageSize':
203			$xmlReader->read();
204			if ($xmlReader->nodeType == \XMLReader::TEXT)
205			{
206			$maximumMessageSize = $xmlReader->value;
207			}
208			break;
209			case 'MessageRetentionPeriod':
210			$xmlReader->read();
211			if ($xmlReader->nodeType == \XMLReader::TEXT)
212			{
213			$messageRetentionPeriod = $xmlReader->value;
214			}
215			break;
216			case 'VisibilityTimeout':
217			$xmlReader->read();
218			if ($xmlReader->nodeType == \XMLReader::TEXT)
219			{
220			$visibilityTimeout = $xmlReader->value;
221			}
222			break;
223			case 'PollingWaitSeconds':
224			$xmlReader->read();
225			if ($xmlReader->nodeType == \XMLReader::TEXT)
226			{
227			$pollingWaitSeconds = $xmlReader->value;
228			}
229			break;
230			case 'QueueName':
231			$xmlReader->read();
232			if ($xmlReader->nodeType == \XMLReader::TEXT)
233			{
234			$queueName = $xmlReader->value;
235			}
236			break;
237			case 'CreateTime':
238			$xmlReader->read();
239			if ($xmlReader->nodeType == \XMLReader::TEXT)
240			{
241			$createTime = $xmlReader->value;
242			}
243			break;
244			case 'LastModifyTime':
245			$xmlReader->read();
246			if ($xmlReader->nodeType == \XMLReader::TEXT)
247			{
248			$lastModifyTime = $xmlReader->value;
249			}
250			break;
251			case 'ActiveMessages':
252			$xmlReader->read();
253			if ($xmlReader->nodeType == \XMLReader::TEXT)
254			{
255			$activeMessages = $xmlReader->value;
256			}
257			break;
258			case 'InactiveMessages':
259			$xmlReader->read();
260			if ($xmlReader->nodeType == \XMLReader::TEXT)
261			{
262			$inactiveMessages = $xmlReader->value;
263			}
264			break;
265			case 'DelayMessages':
266			$xmlReader->read();
267			if ($xmlReader->nodeType == \XMLReader::TEXT)
268			{
269			$delayMessages = $xmlReader->value;
270			}
271			break;
272			case 'LoggingEnabled':
273			$xmlReader->read();
274			if ($xmlReader->nodeType == \XMLReader::TEXT)
275			{
276			$loggingEnabled = $xmlReader->value;
277			if ($loggingEnabled == "True")
278			{
279			$loggingEnabled = True;
280			}
281			else
282			{
283			$loggingEnabled = False;
284			}
285			}
286			break;
287			}
288			}
289			}
290
291			$attributes = new QueueAttributes(
292			$delaySeconds,
293			$maximumMessageSize,
294			$messageRetentionPeriod,
295			$visibilityTimeout,
296			$pollingWaitSeconds,
297			$queueName,
298			$createTime,
299			$lastModifyTime,
300			$activeMessages,
301			$inactiveMessages,
302			$delayMessages,
303			$loggingEnabled);
304			return $attributes;
305			}
306			}
307
308			?>
309

milkmeowo / laravel-queue-aliyun-mns

GitHub Access Token became invalid

Branch — master (b10c57)

QueueAttributes::fromXML() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like