GitHub Access Token became invalid

It seems like the GitHub access token used for retrieving details about this repository from GitHub became invalid. This might prevent certain types of inspections from being run (in particular, everything related to pull requests).
Please ask an admin of your repository to re-new the access token on this website.
Completed
Push — master ( 9a7ea4...53d770 )
by Yang
02:32
created

QueueAttributes   B

Complexity

Total Complexity 48

Size/Duplication

Total Lines 262
Duplicated Lines 0 %

Coupling/Cohesion

Components 1
Dependencies 0

Importance

Changes 2
Bugs 0 Features 0
Metric Value
wmc 48
c 2
b 0
f 0
lcom 1
cbo 0
dl 0
loc 262
rs 8.4864

How to fix   Complexity   

Complex Class

Complex classes like QueueAttributes often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use QueueAttributes, and based on these observations, apply Extract Interface, too.

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