QueueAttributes::fromXML() - Code Metrics - Inspection of "CI 配置。" - abrahamgreyson/laravel-mns - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9a7ea4...53d770 )

by Yang

created 2016-05-02 19:58 UTC

QueueAttributes::fromXML() D

↳ Parent: Project

Complexity

Conditions	25
Paths	25

Size

Total Lines	114
Code Lines	83

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	114
rs	4.5682
cc	25
eloc	83
nc	25
nop	1

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;

    # 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)
    {
        $this->delaySeconds = $delaySeconds;
        $this->maximumMessageSize = $maximumMessageSize;
        $this->messageRetentionPeriod = $messageRetentionPeriod;
        $this->visibilityTimeout = $visibilityTimeout;
        $this->pollingWaitSeconds = $pollingWaitSeconds;

        $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 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);
        }
    }

    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;

        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;
                }
            }
        }

        $attributes = new QueueAttributes(
            $delaySeconds,
            $maximumMessageSize,
            $messageRetentionPeriod,
            $visibilityTimeout,
            $pollingWaitSeconds,
            $queueName,
            $createTime,
            $lastModifyTime,
            $activeMessages,
            $inactiveMessages,
            $delayMessages);
        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
19			# the following attributes cannot be changed
20			private $queueName;
21			private $createTime;
22			private $lastModifyTime;
23			private $activeMessages;
24			private $inactiveMessages;
25			private $delayMessages;
26
27			public function __construct(
28			$delaySeconds = NULL,
29			$maximumMessageSize = NULL,
30			$messageRetentionPeriod = NULL,
31			$visibilityTimeout = NULL,
32			$pollingWaitSeconds = NULL,
33			$queueName = NULL,
34			$createTime = NULL,
35			$lastModifyTime = NULL,
36			$activeMessages = NULL,
37			$inactiveMessages = NULL,
38			$delayMessages = NULL)
39			{
40			$this->delaySeconds = $delaySeconds;
41			$this->maximumMessageSize = $maximumMessageSize;
42			$this->messageRetentionPeriod = $messageRetentionPeriod;
43			$this->visibilityTimeout = $visibilityTimeout;
44			$this->pollingWaitSeconds = $pollingWaitSeconds;
45
46			$this->queueName = $queueName;
47			$this->createTime = $createTime;
48			$this->lastModifyTime = $lastModifyTime;
49			$this->activeMessages = $activeMessages;
50			$this->inactiveMessages = $inactiveMessages;
51			$this->delayMessages = $delayMessages;
52			}
53
54			public function setDelaySeconds($delaySeconds)
55			{
56			$this->delaySeconds = $delaySeconds;
57			}
58
59			public function getDelaySeconds()
60			{
61			return $this->delaySeconds;
62			}
63
64			public function setMaximumMessageSize($maximumMessageSize)
65			{
66			$this->maximumMessageSize = $maximumMessageSize;
67			}
68
69			public function getMaximumMessageSize()
70			{
71			return $this->maximumMessageSize;
72			}
73
74			public function setMessageRetentionPeriod($messageRetentionPeriod)
75			{
76			$this->messageRetentionPeriod = $messageRetentionPeriod;
77			}
78
79			public function getMessageRetentionPeriod()
80			{
81			return $this->messageRetentionPeriod;
82			}
83
84			public function setVisibilityTimeout($visibilityTimeout)
85			{
86			$this->visibilityTimeout = $visibilityTimeout;
87			}
88
89			public function getVisibilityTimeout()
90			{
91			return $this->visibilityTimeout;
92			}
93
94			public function setPollingWaitSeconds($pollingWaitSeconds)
95			{
96			$this->pollingWaitSeconds = $pollingWaitSeconds;
97			}
98
99			public function getPollingWaitSeconds()
100			{
101			return $this->pollingWaitSeconds;
102			}
103
104			public function getQueueName()
105			{
106			return $this->queueName;
107			}
108
109			public function getCreateTime()
110			{
111			return $this->createTime;
112			}
113
114			public function getLastModifyTime()
115			{
116			return $this->lastModifyTime;
117			}
118
119			public function getActiveMessages()
120			{
121			return $this->activeMessages;
122			}
123
124			public function getInactiveMessages()
125			{
126			return $this->inactiveMessages;
127			}
128
129			public function getDelayMessages()
130			{
131			return $this->delayMessages;
132			}
133
134			public function writeXML(\XMLWriter $xmlWriter)
135			{
136			if ($this->delaySeconds != NULL)
137			{
138			$xmlWriter->writeElement(Constants::DELAY_SECONDS, $this->delaySeconds);
139			}
140			if ($this->maximumMessageSize != NULL)
141			{
142			$xmlWriter->writeElement(Constants::MAXIMUM_MESSAGE_SIZE, $this->maximumMessageSize);
143			}
144			if ($this->messageRetentionPeriod != NULL)
145			{
146			$xmlWriter->writeElement(Constants::MESSAGE_RETENTION_PERIOD, $this->messageRetentionPeriod);
147			}
148			if ($this->visibilityTimeout != NULL)
149			{
150			$xmlWriter->writeElement(Constants::VISIBILITY_TIMEOUT, $this->visibilityTimeout);
151			}
152			if ($this->pollingWaitSeconds != NULL)
153			{
154			$xmlWriter->writeElement(Constants::POLLING_WAIT_SECONDS, $this->pollingWaitSeconds);
155			}
156			}
157
158			static public function fromXML(\XMLReader $xmlReader)
159			{
160			$delaySeconds = NULL;
161			$maximumMessageSize = NULL;
162			$messageRetentionPeriod = NULL;
163			$visibilityTimeout = NULL;
164			$pollingWaitSeconds = NULL;
165			$queueName = NULL;
166			$createTime = NULL;
167			$lastModifyTime = NULL;
168			$activeMessages = NULL;
169			$inactiveMessages = NULL;
170			$delayMessages = NULL;
171
172			while ($xmlReader->read())
173			{
174			if ($xmlReader->nodeType == \XMLReader::ELEMENT)
175			{
176			switch ($xmlReader->name) {
177			case 'DelaySeconds':
178			$xmlReader->read();
179			if ($xmlReader->nodeType == \XMLReader::TEXT)
180			{
181			$delaySeconds = $xmlReader->value;
182			}
183			break;
184			case 'MaximumMessageSize':
185			$xmlReader->read();
186			if ($xmlReader->nodeType == \XMLReader::TEXT)
187			{
188			$maximumMessageSize = $xmlReader->value;
189			}
190			break;
191			case 'MessageRetentionPeriod':
192			$xmlReader->read();
193			if ($xmlReader->nodeType == \XMLReader::TEXT)
194			{
195			$messageRetentionPeriod = $xmlReader->value;
196			}
197			break;
198			case 'VisibilityTimeout':
199			$xmlReader->read();
200			if ($xmlReader->nodeType == \XMLReader::TEXT)
201			{
202			$visibilityTimeout = $xmlReader->value;
203			}
204			break;
205			case 'PollingWaitSeconds':
206			$xmlReader->read();
207			if ($xmlReader->nodeType == \XMLReader::TEXT)
208			{
209			$pollingWaitSeconds = $xmlReader->value;
210			}
211			break;
212			case 'QueueName':
213			$xmlReader->read();
214			if ($xmlReader->nodeType == \XMLReader::TEXT)
215			{
216			$queueName = $xmlReader->value;
217			}
218			break;
219			case 'CreateTime':
220			$xmlReader->read();
221			if ($xmlReader->nodeType == \XMLReader::TEXT)
222			{
223			$createTime = $xmlReader->value;
224			}
225			break;
226			case 'LastModifyTime':
227			$xmlReader->read();
228			if ($xmlReader->nodeType == \XMLReader::TEXT)
229			{
230			$lastModifyTime = $xmlReader->value;
231			}
232			break;
233			case 'ActiveMessages':
234			$xmlReader->read();
235			if ($xmlReader->nodeType == \XMLReader::TEXT)
236			{
237			$activeMessages = $xmlReader->value;
238			}
239			break;
240			case 'InactiveMessages':
241			$xmlReader->read();
242			if ($xmlReader->nodeType == \XMLReader::TEXT)
243			{
244			$inactiveMessages = $xmlReader->value;
245			}
246			break;
247			case 'DelayMessages':
248			$xmlReader->read();
249			if ($xmlReader->nodeType == \XMLReader::TEXT)
250			{
251			$delayMessages = $xmlReader->value;
252			}
253			break;
254			}
255			}
256			}
257
258			$attributes = new QueueAttributes(
259			$delaySeconds,
260			$maximumMessageSize,
261			$messageRetentionPeriod,
262			$visibilityTimeout,
263			$pollingWaitSeconds,
264			$queueName,
265			$createTime,
266			$lastModifyTime,
267			$activeMessages,
268			$inactiveMessages,
269			$delayMessages);
270			return $attributes;
271			}
272			}
273
274			?>
275

abrahamgreyson / laravel-mns

GitHub Access Token became invalid

Push — master ( 9a7ea4...53d770 )

QueueAttributes::fromXML() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like