1
16
17
18
19
20 package v1beta2
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28
29 math "math"
30 math_bits "math/bits"
31 reflect "reflect"
32 strings "strings"
33 )
34
35
36 var _ = proto.Marshal
37 var _ = fmt.Errorf
38 var _ = math.Inf
39
40
41
42
43
44 const _ = proto.GoGoProtoPackageIsVersion3
45
46 func (m *ExemptPriorityLevelConfiguration) Reset() { *m = ExemptPriorityLevelConfiguration{} }
47 func (*ExemptPriorityLevelConfiguration) ProtoMessage() {}
48 func (*ExemptPriorityLevelConfiguration) Descriptor() ([]byte, []int) {
49 return fileDescriptor_2e620af2eea53237, []int{0}
50 }
51 func (m *ExemptPriorityLevelConfiguration) XXX_Unmarshal(b []byte) error {
52 return m.Unmarshal(b)
53 }
54 func (m *ExemptPriorityLevelConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
55 b = b[:cap(b)]
56 n, err := m.MarshalToSizedBuffer(b)
57 if err != nil {
58 return nil, err
59 }
60 return b[:n], nil
61 }
62 func (m *ExemptPriorityLevelConfiguration) XXX_Merge(src proto.Message) {
63 xxx_messageInfo_ExemptPriorityLevelConfiguration.Merge(m, src)
64 }
65 func (m *ExemptPriorityLevelConfiguration) XXX_Size() int {
66 return m.Size()
67 }
68 func (m *ExemptPriorityLevelConfiguration) XXX_DiscardUnknown() {
69 xxx_messageInfo_ExemptPriorityLevelConfiguration.DiscardUnknown(m)
70 }
71
72 var xxx_messageInfo_ExemptPriorityLevelConfiguration proto.InternalMessageInfo
73
74 func (m *FlowDistinguisherMethod) Reset() { *m = FlowDistinguisherMethod{} }
75 func (*FlowDistinguisherMethod) ProtoMessage() {}
76 func (*FlowDistinguisherMethod) Descriptor() ([]byte, []int) {
77 return fileDescriptor_2e620af2eea53237, []int{1}
78 }
79 func (m *FlowDistinguisherMethod) XXX_Unmarshal(b []byte) error {
80 return m.Unmarshal(b)
81 }
82 func (m *FlowDistinguisherMethod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
83 b = b[:cap(b)]
84 n, err := m.MarshalToSizedBuffer(b)
85 if err != nil {
86 return nil, err
87 }
88 return b[:n], nil
89 }
90 func (m *FlowDistinguisherMethod) XXX_Merge(src proto.Message) {
91 xxx_messageInfo_FlowDistinguisherMethod.Merge(m, src)
92 }
93 func (m *FlowDistinguisherMethod) XXX_Size() int {
94 return m.Size()
95 }
96 func (m *FlowDistinguisherMethod) XXX_DiscardUnknown() {
97 xxx_messageInfo_FlowDistinguisherMethod.DiscardUnknown(m)
98 }
99
100 var xxx_messageInfo_FlowDistinguisherMethod proto.InternalMessageInfo
101
102 func (m *FlowSchema) Reset() { *m = FlowSchema{} }
103 func (*FlowSchema) ProtoMessage() {}
104 func (*FlowSchema) Descriptor() ([]byte, []int) {
105 return fileDescriptor_2e620af2eea53237, []int{2}
106 }
107 func (m *FlowSchema) XXX_Unmarshal(b []byte) error {
108 return m.Unmarshal(b)
109 }
110 func (m *FlowSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
111 b = b[:cap(b)]
112 n, err := m.MarshalToSizedBuffer(b)
113 if err != nil {
114 return nil, err
115 }
116 return b[:n], nil
117 }
118 func (m *FlowSchema) XXX_Merge(src proto.Message) {
119 xxx_messageInfo_FlowSchema.Merge(m, src)
120 }
121 func (m *FlowSchema) XXX_Size() int {
122 return m.Size()
123 }
124 func (m *FlowSchema) XXX_DiscardUnknown() {
125 xxx_messageInfo_FlowSchema.DiscardUnknown(m)
126 }
127
128 var xxx_messageInfo_FlowSchema proto.InternalMessageInfo
129
130 func (m *FlowSchemaCondition) Reset() { *m = FlowSchemaCondition{} }
131 func (*FlowSchemaCondition) ProtoMessage() {}
132 func (*FlowSchemaCondition) Descriptor() ([]byte, []int) {
133 return fileDescriptor_2e620af2eea53237, []int{3}
134 }
135 func (m *FlowSchemaCondition) XXX_Unmarshal(b []byte) error {
136 return m.Unmarshal(b)
137 }
138 func (m *FlowSchemaCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
139 b = b[:cap(b)]
140 n, err := m.MarshalToSizedBuffer(b)
141 if err != nil {
142 return nil, err
143 }
144 return b[:n], nil
145 }
146 func (m *FlowSchemaCondition) XXX_Merge(src proto.Message) {
147 xxx_messageInfo_FlowSchemaCondition.Merge(m, src)
148 }
149 func (m *FlowSchemaCondition) XXX_Size() int {
150 return m.Size()
151 }
152 func (m *FlowSchemaCondition) XXX_DiscardUnknown() {
153 xxx_messageInfo_FlowSchemaCondition.DiscardUnknown(m)
154 }
155
156 var xxx_messageInfo_FlowSchemaCondition proto.InternalMessageInfo
157
158 func (m *FlowSchemaList) Reset() { *m = FlowSchemaList{} }
159 func (*FlowSchemaList) ProtoMessage() {}
160 func (*FlowSchemaList) Descriptor() ([]byte, []int) {
161 return fileDescriptor_2e620af2eea53237, []int{4}
162 }
163 func (m *FlowSchemaList) XXX_Unmarshal(b []byte) error {
164 return m.Unmarshal(b)
165 }
166 func (m *FlowSchemaList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
167 b = b[:cap(b)]
168 n, err := m.MarshalToSizedBuffer(b)
169 if err != nil {
170 return nil, err
171 }
172 return b[:n], nil
173 }
174 func (m *FlowSchemaList) XXX_Merge(src proto.Message) {
175 xxx_messageInfo_FlowSchemaList.Merge(m, src)
176 }
177 func (m *FlowSchemaList) XXX_Size() int {
178 return m.Size()
179 }
180 func (m *FlowSchemaList) XXX_DiscardUnknown() {
181 xxx_messageInfo_FlowSchemaList.DiscardUnknown(m)
182 }
183
184 var xxx_messageInfo_FlowSchemaList proto.InternalMessageInfo
185
186 func (m *FlowSchemaSpec) Reset() { *m = FlowSchemaSpec{} }
187 func (*FlowSchemaSpec) ProtoMessage() {}
188 func (*FlowSchemaSpec) Descriptor() ([]byte, []int) {
189 return fileDescriptor_2e620af2eea53237, []int{5}
190 }
191 func (m *FlowSchemaSpec) XXX_Unmarshal(b []byte) error {
192 return m.Unmarshal(b)
193 }
194 func (m *FlowSchemaSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
195 b = b[:cap(b)]
196 n, err := m.MarshalToSizedBuffer(b)
197 if err != nil {
198 return nil, err
199 }
200 return b[:n], nil
201 }
202 func (m *FlowSchemaSpec) XXX_Merge(src proto.Message) {
203 xxx_messageInfo_FlowSchemaSpec.Merge(m, src)
204 }
205 func (m *FlowSchemaSpec) XXX_Size() int {
206 return m.Size()
207 }
208 func (m *FlowSchemaSpec) XXX_DiscardUnknown() {
209 xxx_messageInfo_FlowSchemaSpec.DiscardUnknown(m)
210 }
211
212 var xxx_messageInfo_FlowSchemaSpec proto.InternalMessageInfo
213
214 func (m *FlowSchemaStatus) Reset() { *m = FlowSchemaStatus{} }
215 func (*FlowSchemaStatus) ProtoMessage() {}
216 func (*FlowSchemaStatus) Descriptor() ([]byte, []int) {
217 return fileDescriptor_2e620af2eea53237, []int{6}
218 }
219 func (m *FlowSchemaStatus) XXX_Unmarshal(b []byte) error {
220 return m.Unmarshal(b)
221 }
222 func (m *FlowSchemaStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
223 b = b[:cap(b)]
224 n, err := m.MarshalToSizedBuffer(b)
225 if err != nil {
226 return nil, err
227 }
228 return b[:n], nil
229 }
230 func (m *FlowSchemaStatus) XXX_Merge(src proto.Message) {
231 xxx_messageInfo_FlowSchemaStatus.Merge(m, src)
232 }
233 func (m *FlowSchemaStatus) XXX_Size() int {
234 return m.Size()
235 }
236 func (m *FlowSchemaStatus) XXX_DiscardUnknown() {
237 xxx_messageInfo_FlowSchemaStatus.DiscardUnknown(m)
238 }
239
240 var xxx_messageInfo_FlowSchemaStatus proto.InternalMessageInfo
241
242 func (m *GroupSubject) Reset() { *m = GroupSubject{} }
243 func (*GroupSubject) ProtoMessage() {}
244 func (*GroupSubject) Descriptor() ([]byte, []int) {
245 return fileDescriptor_2e620af2eea53237, []int{7}
246 }
247 func (m *GroupSubject) XXX_Unmarshal(b []byte) error {
248 return m.Unmarshal(b)
249 }
250 func (m *GroupSubject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
251 b = b[:cap(b)]
252 n, err := m.MarshalToSizedBuffer(b)
253 if err != nil {
254 return nil, err
255 }
256 return b[:n], nil
257 }
258 func (m *GroupSubject) XXX_Merge(src proto.Message) {
259 xxx_messageInfo_GroupSubject.Merge(m, src)
260 }
261 func (m *GroupSubject) XXX_Size() int {
262 return m.Size()
263 }
264 func (m *GroupSubject) XXX_DiscardUnknown() {
265 xxx_messageInfo_GroupSubject.DiscardUnknown(m)
266 }
267
268 var xxx_messageInfo_GroupSubject proto.InternalMessageInfo
269
270 func (m *LimitResponse) Reset() { *m = LimitResponse{} }
271 func (*LimitResponse) ProtoMessage() {}
272 func (*LimitResponse) Descriptor() ([]byte, []int) {
273 return fileDescriptor_2e620af2eea53237, []int{8}
274 }
275 func (m *LimitResponse) XXX_Unmarshal(b []byte) error {
276 return m.Unmarshal(b)
277 }
278 func (m *LimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
279 b = b[:cap(b)]
280 n, err := m.MarshalToSizedBuffer(b)
281 if err != nil {
282 return nil, err
283 }
284 return b[:n], nil
285 }
286 func (m *LimitResponse) XXX_Merge(src proto.Message) {
287 xxx_messageInfo_LimitResponse.Merge(m, src)
288 }
289 func (m *LimitResponse) XXX_Size() int {
290 return m.Size()
291 }
292 func (m *LimitResponse) XXX_DiscardUnknown() {
293 xxx_messageInfo_LimitResponse.DiscardUnknown(m)
294 }
295
296 var xxx_messageInfo_LimitResponse proto.InternalMessageInfo
297
298 func (m *LimitedPriorityLevelConfiguration) Reset() { *m = LimitedPriorityLevelConfiguration{} }
299 func (*LimitedPriorityLevelConfiguration) ProtoMessage() {}
300 func (*LimitedPriorityLevelConfiguration) Descriptor() ([]byte, []int) {
301 return fileDescriptor_2e620af2eea53237, []int{9}
302 }
303 func (m *LimitedPriorityLevelConfiguration) XXX_Unmarshal(b []byte) error {
304 return m.Unmarshal(b)
305 }
306 func (m *LimitedPriorityLevelConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
307 b = b[:cap(b)]
308 n, err := m.MarshalToSizedBuffer(b)
309 if err != nil {
310 return nil, err
311 }
312 return b[:n], nil
313 }
314 func (m *LimitedPriorityLevelConfiguration) XXX_Merge(src proto.Message) {
315 xxx_messageInfo_LimitedPriorityLevelConfiguration.Merge(m, src)
316 }
317 func (m *LimitedPriorityLevelConfiguration) XXX_Size() int {
318 return m.Size()
319 }
320 func (m *LimitedPriorityLevelConfiguration) XXX_DiscardUnknown() {
321 xxx_messageInfo_LimitedPriorityLevelConfiguration.DiscardUnknown(m)
322 }
323
324 var xxx_messageInfo_LimitedPriorityLevelConfiguration proto.InternalMessageInfo
325
326 func (m *NonResourcePolicyRule) Reset() { *m = NonResourcePolicyRule{} }
327 func (*NonResourcePolicyRule) ProtoMessage() {}
328 func (*NonResourcePolicyRule) Descriptor() ([]byte, []int) {
329 return fileDescriptor_2e620af2eea53237, []int{10}
330 }
331 func (m *NonResourcePolicyRule) XXX_Unmarshal(b []byte) error {
332 return m.Unmarshal(b)
333 }
334 func (m *NonResourcePolicyRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
335 b = b[:cap(b)]
336 n, err := m.MarshalToSizedBuffer(b)
337 if err != nil {
338 return nil, err
339 }
340 return b[:n], nil
341 }
342 func (m *NonResourcePolicyRule) XXX_Merge(src proto.Message) {
343 xxx_messageInfo_NonResourcePolicyRule.Merge(m, src)
344 }
345 func (m *NonResourcePolicyRule) XXX_Size() int {
346 return m.Size()
347 }
348 func (m *NonResourcePolicyRule) XXX_DiscardUnknown() {
349 xxx_messageInfo_NonResourcePolicyRule.DiscardUnknown(m)
350 }
351
352 var xxx_messageInfo_NonResourcePolicyRule proto.InternalMessageInfo
353
354 func (m *PolicyRulesWithSubjects) Reset() { *m = PolicyRulesWithSubjects{} }
355 func (*PolicyRulesWithSubjects) ProtoMessage() {}
356 func (*PolicyRulesWithSubjects) Descriptor() ([]byte, []int) {
357 return fileDescriptor_2e620af2eea53237, []int{11}
358 }
359 func (m *PolicyRulesWithSubjects) XXX_Unmarshal(b []byte) error {
360 return m.Unmarshal(b)
361 }
362 func (m *PolicyRulesWithSubjects) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
363 b = b[:cap(b)]
364 n, err := m.MarshalToSizedBuffer(b)
365 if err != nil {
366 return nil, err
367 }
368 return b[:n], nil
369 }
370 func (m *PolicyRulesWithSubjects) XXX_Merge(src proto.Message) {
371 xxx_messageInfo_PolicyRulesWithSubjects.Merge(m, src)
372 }
373 func (m *PolicyRulesWithSubjects) XXX_Size() int {
374 return m.Size()
375 }
376 func (m *PolicyRulesWithSubjects) XXX_DiscardUnknown() {
377 xxx_messageInfo_PolicyRulesWithSubjects.DiscardUnknown(m)
378 }
379
380 var xxx_messageInfo_PolicyRulesWithSubjects proto.InternalMessageInfo
381
382 func (m *PriorityLevelConfiguration) Reset() { *m = PriorityLevelConfiguration{} }
383 func (*PriorityLevelConfiguration) ProtoMessage() {}
384 func (*PriorityLevelConfiguration) Descriptor() ([]byte, []int) {
385 return fileDescriptor_2e620af2eea53237, []int{12}
386 }
387 func (m *PriorityLevelConfiguration) XXX_Unmarshal(b []byte) error {
388 return m.Unmarshal(b)
389 }
390 func (m *PriorityLevelConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
391 b = b[:cap(b)]
392 n, err := m.MarshalToSizedBuffer(b)
393 if err != nil {
394 return nil, err
395 }
396 return b[:n], nil
397 }
398 func (m *PriorityLevelConfiguration) XXX_Merge(src proto.Message) {
399 xxx_messageInfo_PriorityLevelConfiguration.Merge(m, src)
400 }
401 func (m *PriorityLevelConfiguration) XXX_Size() int {
402 return m.Size()
403 }
404 func (m *PriorityLevelConfiguration) XXX_DiscardUnknown() {
405 xxx_messageInfo_PriorityLevelConfiguration.DiscardUnknown(m)
406 }
407
408 var xxx_messageInfo_PriorityLevelConfiguration proto.InternalMessageInfo
409
410 func (m *PriorityLevelConfigurationCondition) Reset() { *m = PriorityLevelConfigurationCondition{} }
411 func (*PriorityLevelConfigurationCondition) ProtoMessage() {}
412 func (*PriorityLevelConfigurationCondition) Descriptor() ([]byte, []int) {
413 return fileDescriptor_2e620af2eea53237, []int{13}
414 }
415 func (m *PriorityLevelConfigurationCondition) XXX_Unmarshal(b []byte) error {
416 return m.Unmarshal(b)
417 }
418 func (m *PriorityLevelConfigurationCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
419 b = b[:cap(b)]
420 n, err := m.MarshalToSizedBuffer(b)
421 if err != nil {
422 return nil, err
423 }
424 return b[:n], nil
425 }
426 func (m *PriorityLevelConfigurationCondition) XXX_Merge(src proto.Message) {
427 xxx_messageInfo_PriorityLevelConfigurationCondition.Merge(m, src)
428 }
429 func (m *PriorityLevelConfigurationCondition) XXX_Size() int {
430 return m.Size()
431 }
432 func (m *PriorityLevelConfigurationCondition) XXX_DiscardUnknown() {
433 xxx_messageInfo_PriorityLevelConfigurationCondition.DiscardUnknown(m)
434 }
435
436 var xxx_messageInfo_PriorityLevelConfigurationCondition proto.InternalMessageInfo
437
438 func (m *PriorityLevelConfigurationList) Reset() { *m = PriorityLevelConfigurationList{} }
439 func (*PriorityLevelConfigurationList) ProtoMessage() {}
440 func (*PriorityLevelConfigurationList) Descriptor() ([]byte, []int) {
441 return fileDescriptor_2e620af2eea53237, []int{14}
442 }
443 func (m *PriorityLevelConfigurationList) XXX_Unmarshal(b []byte) error {
444 return m.Unmarshal(b)
445 }
446 func (m *PriorityLevelConfigurationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
447 b = b[:cap(b)]
448 n, err := m.MarshalToSizedBuffer(b)
449 if err != nil {
450 return nil, err
451 }
452 return b[:n], nil
453 }
454 func (m *PriorityLevelConfigurationList) XXX_Merge(src proto.Message) {
455 xxx_messageInfo_PriorityLevelConfigurationList.Merge(m, src)
456 }
457 func (m *PriorityLevelConfigurationList) XXX_Size() int {
458 return m.Size()
459 }
460 func (m *PriorityLevelConfigurationList) XXX_DiscardUnknown() {
461 xxx_messageInfo_PriorityLevelConfigurationList.DiscardUnknown(m)
462 }
463
464 var xxx_messageInfo_PriorityLevelConfigurationList proto.InternalMessageInfo
465
466 func (m *PriorityLevelConfigurationReference) Reset() { *m = PriorityLevelConfigurationReference{} }
467 func (*PriorityLevelConfigurationReference) ProtoMessage() {}
468 func (*PriorityLevelConfigurationReference) Descriptor() ([]byte, []int) {
469 return fileDescriptor_2e620af2eea53237, []int{15}
470 }
471 func (m *PriorityLevelConfigurationReference) XXX_Unmarshal(b []byte) error {
472 return m.Unmarshal(b)
473 }
474 func (m *PriorityLevelConfigurationReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
475 b = b[:cap(b)]
476 n, err := m.MarshalToSizedBuffer(b)
477 if err != nil {
478 return nil, err
479 }
480 return b[:n], nil
481 }
482 func (m *PriorityLevelConfigurationReference) XXX_Merge(src proto.Message) {
483 xxx_messageInfo_PriorityLevelConfigurationReference.Merge(m, src)
484 }
485 func (m *PriorityLevelConfigurationReference) XXX_Size() int {
486 return m.Size()
487 }
488 func (m *PriorityLevelConfigurationReference) XXX_DiscardUnknown() {
489 xxx_messageInfo_PriorityLevelConfigurationReference.DiscardUnknown(m)
490 }
491
492 var xxx_messageInfo_PriorityLevelConfigurationReference proto.InternalMessageInfo
493
494 func (m *PriorityLevelConfigurationSpec) Reset() { *m = PriorityLevelConfigurationSpec{} }
495 func (*PriorityLevelConfigurationSpec) ProtoMessage() {}
496 func (*PriorityLevelConfigurationSpec) Descriptor() ([]byte, []int) {
497 return fileDescriptor_2e620af2eea53237, []int{16}
498 }
499 func (m *PriorityLevelConfigurationSpec) XXX_Unmarshal(b []byte) error {
500 return m.Unmarshal(b)
501 }
502 func (m *PriorityLevelConfigurationSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
503 b = b[:cap(b)]
504 n, err := m.MarshalToSizedBuffer(b)
505 if err != nil {
506 return nil, err
507 }
508 return b[:n], nil
509 }
510 func (m *PriorityLevelConfigurationSpec) XXX_Merge(src proto.Message) {
511 xxx_messageInfo_PriorityLevelConfigurationSpec.Merge(m, src)
512 }
513 func (m *PriorityLevelConfigurationSpec) XXX_Size() int {
514 return m.Size()
515 }
516 func (m *PriorityLevelConfigurationSpec) XXX_DiscardUnknown() {
517 xxx_messageInfo_PriorityLevelConfigurationSpec.DiscardUnknown(m)
518 }
519
520 var xxx_messageInfo_PriorityLevelConfigurationSpec proto.InternalMessageInfo
521
522 func (m *PriorityLevelConfigurationStatus) Reset() { *m = PriorityLevelConfigurationStatus{} }
523 func (*PriorityLevelConfigurationStatus) ProtoMessage() {}
524 func (*PriorityLevelConfigurationStatus) Descriptor() ([]byte, []int) {
525 return fileDescriptor_2e620af2eea53237, []int{17}
526 }
527 func (m *PriorityLevelConfigurationStatus) XXX_Unmarshal(b []byte) error {
528 return m.Unmarshal(b)
529 }
530 func (m *PriorityLevelConfigurationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
531 b = b[:cap(b)]
532 n, err := m.MarshalToSizedBuffer(b)
533 if err != nil {
534 return nil, err
535 }
536 return b[:n], nil
537 }
538 func (m *PriorityLevelConfigurationStatus) XXX_Merge(src proto.Message) {
539 xxx_messageInfo_PriorityLevelConfigurationStatus.Merge(m, src)
540 }
541 func (m *PriorityLevelConfigurationStatus) XXX_Size() int {
542 return m.Size()
543 }
544 func (m *PriorityLevelConfigurationStatus) XXX_DiscardUnknown() {
545 xxx_messageInfo_PriorityLevelConfigurationStatus.DiscardUnknown(m)
546 }
547
548 var xxx_messageInfo_PriorityLevelConfigurationStatus proto.InternalMessageInfo
549
550 func (m *QueuingConfiguration) Reset() { *m = QueuingConfiguration{} }
551 func (*QueuingConfiguration) ProtoMessage() {}
552 func (*QueuingConfiguration) Descriptor() ([]byte, []int) {
553 return fileDescriptor_2e620af2eea53237, []int{18}
554 }
555 func (m *QueuingConfiguration) XXX_Unmarshal(b []byte) error {
556 return m.Unmarshal(b)
557 }
558 func (m *QueuingConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
559 b = b[:cap(b)]
560 n, err := m.MarshalToSizedBuffer(b)
561 if err != nil {
562 return nil, err
563 }
564 return b[:n], nil
565 }
566 func (m *QueuingConfiguration) XXX_Merge(src proto.Message) {
567 xxx_messageInfo_QueuingConfiguration.Merge(m, src)
568 }
569 func (m *QueuingConfiguration) XXX_Size() int {
570 return m.Size()
571 }
572 func (m *QueuingConfiguration) XXX_DiscardUnknown() {
573 xxx_messageInfo_QueuingConfiguration.DiscardUnknown(m)
574 }
575
576 var xxx_messageInfo_QueuingConfiguration proto.InternalMessageInfo
577
578 func (m *ResourcePolicyRule) Reset() { *m = ResourcePolicyRule{} }
579 func (*ResourcePolicyRule) ProtoMessage() {}
580 func (*ResourcePolicyRule) Descriptor() ([]byte, []int) {
581 return fileDescriptor_2e620af2eea53237, []int{19}
582 }
583 func (m *ResourcePolicyRule) XXX_Unmarshal(b []byte) error {
584 return m.Unmarshal(b)
585 }
586 func (m *ResourcePolicyRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
587 b = b[:cap(b)]
588 n, err := m.MarshalToSizedBuffer(b)
589 if err != nil {
590 return nil, err
591 }
592 return b[:n], nil
593 }
594 func (m *ResourcePolicyRule) XXX_Merge(src proto.Message) {
595 xxx_messageInfo_ResourcePolicyRule.Merge(m, src)
596 }
597 func (m *ResourcePolicyRule) XXX_Size() int {
598 return m.Size()
599 }
600 func (m *ResourcePolicyRule) XXX_DiscardUnknown() {
601 xxx_messageInfo_ResourcePolicyRule.DiscardUnknown(m)
602 }
603
604 var xxx_messageInfo_ResourcePolicyRule proto.InternalMessageInfo
605
606 func (m *ServiceAccountSubject) Reset() { *m = ServiceAccountSubject{} }
607 func (*ServiceAccountSubject) ProtoMessage() {}
608 func (*ServiceAccountSubject) Descriptor() ([]byte, []int) {
609 return fileDescriptor_2e620af2eea53237, []int{20}
610 }
611 func (m *ServiceAccountSubject) XXX_Unmarshal(b []byte) error {
612 return m.Unmarshal(b)
613 }
614 func (m *ServiceAccountSubject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
615 b = b[:cap(b)]
616 n, err := m.MarshalToSizedBuffer(b)
617 if err != nil {
618 return nil, err
619 }
620 return b[:n], nil
621 }
622 func (m *ServiceAccountSubject) XXX_Merge(src proto.Message) {
623 xxx_messageInfo_ServiceAccountSubject.Merge(m, src)
624 }
625 func (m *ServiceAccountSubject) XXX_Size() int {
626 return m.Size()
627 }
628 func (m *ServiceAccountSubject) XXX_DiscardUnknown() {
629 xxx_messageInfo_ServiceAccountSubject.DiscardUnknown(m)
630 }
631
632 var xxx_messageInfo_ServiceAccountSubject proto.InternalMessageInfo
633
634 func (m *Subject) Reset() { *m = Subject{} }
635 func (*Subject) ProtoMessage() {}
636 func (*Subject) Descriptor() ([]byte, []int) {
637 return fileDescriptor_2e620af2eea53237, []int{21}
638 }
639 func (m *Subject) XXX_Unmarshal(b []byte) error {
640 return m.Unmarshal(b)
641 }
642 func (m *Subject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
643 b = b[:cap(b)]
644 n, err := m.MarshalToSizedBuffer(b)
645 if err != nil {
646 return nil, err
647 }
648 return b[:n], nil
649 }
650 func (m *Subject) XXX_Merge(src proto.Message) {
651 xxx_messageInfo_Subject.Merge(m, src)
652 }
653 func (m *Subject) XXX_Size() int {
654 return m.Size()
655 }
656 func (m *Subject) XXX_DiscardUnknown() {
657 xxx_messageInfo_Subject.DiscardUnknown(m)
658 }
659
660 var xxx_messageInfo_Subject proto.InternalMessageInfo
661
662 func (m *UserSubject) Reset() { *m = UserSubject{} }
663 func (*UserSubject) ProtoMessage() {}
664 func (*UserSubject) Descriptor() ([]byte, []int) {
665 return fileDescriptor_2e620af2eea53237, []int{22}
666 }
667 func (m *UserSubject) XXX_Unmarshal(b []byte) error {
668 return m.Unmarshal(b)
669 }
670 func (m *UserSubject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
671 b = b[:cap(b)]
672 n, err := m.MarshalToSizedBuffer(b)
673 if err != nil {
674 return nil, err
675 }
676 return b[:n], nil
677 }
678 func (m *UserSubject) XXX_Merge(src proto.Message) {
679 xxx_messageInfo_UserSubject.Merge(m, src)
680 }
681 func (m *UserSubject) XXX_Size() int {
682 return m.Size()
683 }
684 func (m *UserSubject) XXX_DiscardUnknown() {
685 xxx_messageInfo_UserSubject.DiscardUnknown(m)
686 }
687
688 var xxx_messageInfo_UserSubject proto.InternalMessageInfo
689
690 func init() {
691 proto.RegisterType((*ExemptPriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.ExemptPriorityLevelConfiguration")
692 proto.RegisterType((*FlowDistinguisherMethod)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowDistinguisherMethod")
693 proto.RegisterType((*FlowSchema)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchema")
694 proto.RegisterType((*FlowSchemaCondition)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaCondition")
695 proto.RegisterType((*FlowSchemaList)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaList")
696 proto.RegisterType((*FlowSchemaSpec)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaSpec")
697 proto.RegisterType((*FlowSchemaStatus)(nil), "k8s.io.api.flowcontrol.v1beta2.FlowSchemaStatus")
698 proto.RegisterType((*GroupSubject)(nil), "k8s.io.api.flowcontrol.v1beta2.GroupSubject")
699 proto.RegisterType((*LimitResponse)(nil), "k8s.io.api.flowcontrol.v1beta2.LimitResponse")
700 proto.RegisterType((*LimitedPriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration")
701 proto.RegisterType((*NonResourcePolicyRule)(nil), "k8s.io.api.flowcontrol.v1beta2.NonResourcePolicyRule")
702 proto.RegisterType((*PolicyRulesWithSubjects)(nil), "k8s.io.api.flowcontrol.v1beta2.PolicyRulesWithSubjects")
703 proto.RegisterType((*PriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfiguration")
704 proto.RegisterType((*PriorityLevelConfigurationCondition)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition")
705 proto.RegisterType((*PriorityLevelConfigurationList)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationList")
706 proto.RegisterType((*PriorityLevelConfigurationReference)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference")
707 proto.RegisterType((*PriorityLevelConfigurationSpec)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec")
708 proto.RegisterType((*PriorityLevelConfigurationStatus)(nil), "k8s.io.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus")
709 proto.RegisterType((*QueuingConfiguration)(nil), "k8s.io.api.flowcontrol.v1beta2.QueuingConfiguration")
710 proto.RegisterType((*ResourcePolicyRule)(nil), "k8s.io.api.flowcontrol.v1beta2.ResourcePolicyRule")
711 proto.RegisterType((*ServiceAccountSubject)(nil), "k8s.io.api.flowcontrol.v1beta2.ServiceAccountSubject")
712 proto.RegisterType((*Subject)(nil), "k8s.io.api.flowcontrol.v1beta2.Subject")
713 proto.RegisterType((*UserSubject)(nil), "k8s.io.api.flowcontrol.v1beta2.UserSubject")
714 }
715
716 func init() {
717 proto.RegisterFile("k8s.io/api/flowcontrol/v1beta2/generated.proto", fileDescriptor_2e620af2eea53237)
718 }
719
720 var fileDescriptor_2e620af2eea53237 = []byte{
721
722 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x73, 0xdb, 0xd4,
723 0x16, 0x8f, 0x1c, 0x3b, 0x89, 0x4f, 0x3e, 0x7b, 0xd3, 0x4c, 0xfc, 0xd2, 0x37, 0x76, 0xaa, 0x37,
724 0xf3, 0xfa, 0x1e, 0x6d, 0xe5, 0x36, 0xb4, 0xb4, 0xc0, 0xf0, 0x11, 0xa5, 0xa5, 0x94, 0x26, 0x69,
725 0x7a, 0xd3, 0x42, 0xa7, 0x74, 0x86, 0x2a, 0xf2, 0x8d, 0xad, 0xc6, 0xfa, 0xa8, 0xae, 0x94, 0x10,
726 0xba, 0x61, 0xf8, 0x0b, 0x58, 0xc3, 0x92, 0x05, 0x2b, 0x36, 0x6c, 0x59, 0xb0, 0xa4, 0xc3, 0xaa,
727 0xcb, 0xae, 0x0c, 0x35, 0x2b, 0xfe, 0x03, 0xe8, 0x0c, 0x33, 0xcc, 0xbd, 0xba, 0x92, 0x2c, 0xdb,
728 0xb2, 0x3c, 0xed, 0x4c, 0x57, 0xec, 0xa2, 0x73, 0x7f, 0xe7, 0x77, 0xee, 0x39, 0xf7, 0x7c, 0x39,
729 0xa0, 0xec, 0x5d, 0xa4, 0x8a, 0x61, 0x57, 0x35, 0xc7, 0xa8, 0xee, 0x36, 0xed, 0x03, 0xdd, 0xb6,
730 0x3c, 0xd7, 0x6e, 0x56, 0xf7, 0xcf, 0xee, 0x10, 0x4f, 0x5b, 0xa9, 0xd6, 0x89, 0x45, 0x5c, 0xcd,
731 0x23, 0x35, 0xc5, 0x71, 0x6d, 0xcf, 0x46, 0xe5, 0x00, 0xaf, 0x68, 0x8e, 0xa1, 0x74, 0xe0, 0x15,
732 0x81, 0x5f, 0x3a, 0x5d, 0x37, 0xbc, 0x86, 0xbf, 0xa3, 0xe8, 0xb6, 0x59, 0xad, 0xdb, 0x75, 0xbb,
733 0xca, 0xd5, 0x76, 0xfc, 0x5d, 0xfe, 0xc5, 0x3f, 0xf8, 0x5f, 0x01, 0xdd, 0xd2, 0xb9, 0xd8, 0xbc,
734 0xa9, 0xe9, 0x0d, 0xc3, 0x22, 0xee, 0x61, 0xd5, 0xd9, 0xab, 0x33, 0x01, 0xad, 0x9a, 0xc4, 0xd3,
735 0xaa, 0xfb, 0x67, 0xbb, 0x2f, 0xb1, 0x54, 0x4d, 0xd3, 0x72, 0x7d, 0xcb, 0x33, 0x4c, 0xd2, 0xa3,
736 0xf0, 0x5a, 0x96, 0x02, 0xd5, 0x1b, 0xc4, 0xd4, 0xba, 0xf5, 0xe4, 0x1f, 0x24, 0x58, 0xbe, 0xfc,
737 0x29, 0x31, 0x1d, 0x6f, 0xcb, 0x35, 0x6c, 0xd7, 0xf0, 0x0e, 0xd7, 0xc9, 0x3e, 0x69, 0xae, 0xd9,
738 0xd6, 0xae, 0x51, 0xf7, 0x5d, 0xcd, 0x33, 0x6c, 0x0b, 0xdd, 0x86, 0x92, 0x65, 0x9b, 0x86, 0xa5,
739 0x31, 0xb9, 0xee, 0xbb, 0x2e, 0xb1, 0xf4, 0xc3, 0xed, 0x86, 0xe6, 0x12, 0x5a, 0x92, 0x96, 0xa5,
740 0xff, 0x15, 0xd4, 0x7f, 0xb7, 0x5b, 0x95, 0xd2, 0x66, 0x0a, 0x06, 0xa7, 0x6a, 0xa3, 0xb7, 0x60,
741 0xb6, 0x49, 0xac, 0x9a, 0xb6, 0xd3, 0x24, 0x5b, 0xc4, 0xd5, 0x89, 0xe5, 0x95, 0x72, 0x9c, 0x70,
742 0xbe, 0xdd, 0xaa, 0xcc, 0xae, 0x27, 0x8f, 0x70, 0x37, 0x56, 0xbe, 0x03, 0x8b, 0xef, 0x35, 0xed,
743 0x83, 0x4b, 0x06, 0xf5, 0x0c, 0xab, 0xee, 0x1b, 0xb4, 0x41, 0xdc, 0x0d, 0xe2, 0x35, 0xec, 0x1a,
744 0x7a, 0x07, 0xf2, 0xde, 0xa1, 0x43, 0xf8, 0xfd, 0x8a, 0xea, 0xc9, 0x47, 0xad, 0xca, 0x48, 0xbb,
745 0x55, 0xc9, 0xdf, 0x3c, 0x74, 0xc8, 0xb3, 0x56, 0xe5, 0x58, 0x8a, 0x1a, 0x3b, 0xc6, 0x5c, 0x51,
746 0xfe, 0x2a, 0x07, 0xc0, 0x50, 0xdb, 0x3c, 0x70, 0xe8, 0x1e, 0x4c, 0xb0, 0xc7, 0xaa, 0x69, 0x9e,
747 0xc6, 0x39, 0x27, 0x57, 0xce, 0x28, 0x71, 0xa6, 0x44, 0x31, 0x57, 0x9c, 0xbd, 0x3a, 0x13, 0x50,
748 0x85, 0xa1, 0x95, 0xfd, 0xb3, 0xca, 0xf5, 0x9d, 0xfb, 0x44, 0xf7, 0x36, 0x88, 0xa7, 0xa9, 0x48,
749 0xdc, 0x02, 0x62, 0x19, 0x8e, 0x58, 0xd1, 0x16, 0xe4, 0xa9, 0x43, 0x74, 0x1e, 0x80, 0xc9, 0x15,
750 0x45, 0x19, 0x9c, 0x87, 0x4a, 0x7c, 0xb7, 0x6d, 0x87, 0xe8, 0xea, 0x54, 0xe8, 0x21, 0xfb, 0xc2,
751 0x9c, 0x09, 0xdd, 0x86, 0x31, 0xea, 0x69, 0x9e, 0x4f, 0x4b, 0xa3, 0x3d, 0x37, 0xce, 0xe2, 0xe4,
752 0x7a, 0xea, 0x8c, 0x60, 0x1d, 0x0b, 0xbe, 0xb1, 0xe0, 0x93, 0x9f, 0xe4, 0x60, 0x3e, 0x06, 0xaf,
753 0xd9, 0x56, 0xcd, 0xe0, 0x99, 0xf2, 0x66, 0x22, 0xea, 0x27, 0xba, 0xa2, 0xbe, 0xd8, 0x47, 0x25,
754 0x8e, 0x38, 0x7a, 0x3d, 0xba, 0x6e, 0x8e, 0xab, 0x1f, 0x4f, 0x1a, 0x7f, 0xd6, 0xaa, 0xcc, 0x46,
755 0x6a, 0xc9, 0xfb, 0xa0, 0x7d, 0x40, 0x4d, 0x8d, 0x7a, 0x37, 0x5d, 0xcd, 0xa2, 0x01, 0xad, 0x61,
756 0x12, 0xe1, 0xf5, 0x2b, 0xc3, 0xbd, 0x13, 0xd3, 0x50, 0x97, 0x84, 0x49, 0xb4, 0xde, 0xc3, 0x86,
757 0xfb, 0x58, 0x40, 0xff, 0x85, 0x31, 0x97, 0x68, 0xd4, 0xb6, 0x4a, 0x79, 0x7e, 0xe5, 0x28, 0x5e,
758 0x98, 0x4b, 0xb1, 0x38, 0x45, 0xff, 0x87, 0x71, 0x93, 0x50, 0xaa, 0xd5, 0x49, 0xa9, 0xc0, 0x81,
759 0xb3, 0x02, 0x38, 0xbe, 0x11, 0x88, 0x71, 0x78, 0x2e, 0xff, 0x28, 0xc1, 0x4c, 0x1c, 0xa7, 0x75,
760 0x83, 0x7a, 0xe8, 0x6e, 0x4f, 0xee, 0x29, 0xc3, 0xf9, 0xc4, 0xb4, 0x79, 0xe6, 0xcd, 0x09, 0x73,
761 0x13, 0xa1, 0xa4, 0x23, 0xef, 0xae, 0x43, 0xc1, 0xf0, 0x88, 0xc9, 0xa2, 0x3e, 0xda, 0x15, 0xae,
762 0x8c, 0x24, 0x51, 0xa7, 0x05, 0x6d, 0xe1, 0x2a, 0x23, 0xc0, 0x01, 0x8f, 0xfc, 0xfb, 0x68, 0xa7,
763 0x07, 0x2c, 0x1f, 0xd1, 0xb7, 0x12, 0x2c, 0x39, 0xa9, 0x0d, 0x46, 0x38, 0xb5, 0x96, 0x65, 0x39,
764 0xbd, 0x45, 0x61, 0xb2, 0x4b, 0x58, 0x5f, 0x21, 0xaa, 0x2c, 0xae, 0xb4, 0x34, 0x00, 0x3c, 0xe0,
765 0x2a, 0xe8, 0x03, 0x40, 0xa6, 0xe6, 0xb1, 0x88, 0xd6, 0xb7, 0x5c, 0xa2, 0x93, 0x1a, 0x63, 0x15,
766 0x4d, 0x29, 0xca, 0x8e, 0x8d, 0x1e, 0x04, 0xee, 0xa3, 0x85, 0xbe, 0x90, 0x60, 0xbe, 0xd6, 0xdb,
767 0x64, 0x44, 0x5e, 0x5e, 0x18, 0x26, 0xd0, 0x7d, 0x7a, 0x94, 0xba, 0xd8, 0x6e, 0x55, 0xe6, 0xfb,
768 0x1c, 0xe0, 0x7e, 0xc6, 0xd0, 0x5d, 0x28, 0xb8, 0x7e, 0x93, 0xd0, 0x52, 0x9e, 0x3f, 0x6f, 0xa6,
769 0xd5, 0x2d, 0xbb, 0x69, 0xe8, 0x87, 0x98, 0xa9, 0x7c, 0x64, 0x78, 0x8d, 0x6d, 0x9f, 0xf7, 0x2a,
770 0x1a, 0xbf, 0x35, 0x3f, 0xc2, 0x01, 0xa9, 0xfc, 0x10, 0xe6, 0xba, 0x9b, 0x06, 0xaa, 0x03, 0xe8,
771 0x61, 0x9d, 0xb2, 0x01, 0xc1, 0xcc, 0xbe, 0x3a, 0x7c, 0x56, 0x45, 0x35, 0x1e, 0xf7, 0xcb, 0x48,
772 0x44, 0x71, 0x07, 0xb5, 0x7c, 0x06, 0xa6, 0xae, 0xb8, 0xb6, 0xef, 0x88, 0x3b, 0xa2, 0x65, 0xc8,
773 0x5b, 0x9a, 0x19, 0x76, 0x9f, 0xa8, 0x23, 0x6e, 0x6a, 0x26, 0xc1, 0xfc, 0x44, 0xfe, 0x46, 0x82,
774 0xe9, 0x75, 0xc3, 0x34, 0x3c, 0x4c, 0xa8, 0x63, 0x5b, 0x94, 0xa0, 0xf3, 0x89, 0x8e, 0x75, 0xbc,
775 0xab, 0x63, 0x1d, 0x49, 0x80, 0x3b, 0x7a, 0xd5, 0xc7, 0x30, 0xfe, 0xc0, 0x27, 0xbe, 0x61, 0xd5,
776 0x45, 0xbf, 0x3e, 0x97, 0xe5, 0xe0, 0x8d, 0x00, 0x9e, 0xc8, 0x36, 0x75, 0x92, 0xb5, 0x00, 0x71,
777 0x82, 0x43, 0x46, 0xf9, 0xaf, 0x1c, 0x1c, 0xe7, 0x86, 0x49, 0x6d, 0xc0, 0x54, 0xbe, 0x0b, 0x25,
778 0x8d, 0x52, 0xdf, 0x25, 0xb5, 0xb4, 0xa9, 0xbc, 0x2c, 0xbc, 0x29, 0xad, 0xa6, 0xe0, 0x70, 0x2a,
779 0x03, 0xba, 0x0f, 0xd3, 0xcd, 0x4e, 0xdf, 0x85, 0x9b, 0xa7, 0xb3, 0xdc, 0x4c, 0x04, 0x4c, 0x5d,
780 0x10, 0x37, 0x48, 0x06, 0x1d, 0x27, 0xa9, 0xfb, 0x6d, 0x01, 0xa3, 0xc3, 0x6f, 0x01, 0xe8, 0x3a,
781 0x2c, 0xec, 0xd8, 0xae, 0x6b, 0x1f, 0x18, 0x56, 0x9d, 0xdb, 0x09, 0x49, 0xf2, 0x9c, 0xe4, 0x5f,
782 0xed, 0x56, 0x65, 0x41, 0xed, 0x07, 0xc0, 0xfd, 0xf5, 0xe4, 0x03, 0x58, 0xd8, 0x64, 0x3d, 0x85,
783 0xda, 0xbe, 0xab, 0x93, 0xb8, 0x20, 0x50, 0x05, 0x0a, 0xfb, 0xc4, 0xdd, 0x09, 0x92, 0xba, 0xa8,
784 0x16, 0x59, 0x39, 0x7c, 0xc8, 0x04, 0x38, 0x90, 0x33, 0x4f, 0xac, 0x58, 0xf3, 0x16, 0x5e, 0xa7,
785 0xa5, 0x31, 0x0e, 0xe5, 0x9e, 0x6c, 0x26, 0x8f, 0x70, 0x37, 0x56, 0x6e, 0xe5, 0x60, 0x31, 0xa5,
786 0xfe, 0xd0, 0x2d, 0x98, 0xa0, 0xe2, 0x6f, 0x51, 0x53, 0x27, 0xb2, 0xde, 0x42, 0xe8, 0xc6, 0xdd,
787 0x3f, 0x24, 0xc3, 0x11, 0x15, 0xb2, 0x61, 0xda, 0x15, 0x57, 0xe0, 0x36, 0xc5, 0x14, 0x58, 0xc9,
788 0xe2, 0xee, 0x8d, 0x4e, 0xfc, 0xd8, 0xb8, 0x93, 0x10, 0x27, 0xf9, 0xd1, 0x43, 0x98, 0xeb, 0x70,
789 0x3b, 0xb0, 0x39, 0xca, 0x6d, 0x9e, 0xcf, 0xb2, 0xd9, 0xf7, 0x51, 0xd4, 0x92, 0x30, 0x3b, 0xb7,
790 0xd9, 0x45, 0x8b, 0x7b, 0x0c, 0xc9, 0x3f, 0xe7, 0x60, 0xc0, 0x60, 0x78, 0x09, 0x4b, 0xde, 0xbd,
791 0xc4, 0x92, 0xf7, 0xf6, 0xf3, 0x4f, 0xbc, 0xd4, 0xa5, 0xaf, 0xd1, 0xb5, 0xf4, 0xbd, 0xfb, 0x02,
792 0x36, 0x06, 0x2f, 0x81, 0x7f, 0xe4, 0xe0, 0x3f, 0xe9, 0xca, 0xf1, 0x52, 0x78, 0x2d, 0xd1, 0x62,
793 0x2f, 0x74, 0xb5, 0xd8, 0x13, 0x43, 0x50, 0xfc, 0xb3, 0x24, 0x76, 0x2d, 0x89, 0xbf, 0x48, 0x50,
794 0x4e, 0x8f, 0xdb, 0x4b, 0x58, 0x1a, 0x3f, 0x49, 0x2e, 0x8d, 0x6f, 0x3c, 0x7f, 0x92, 0xa5, 0x2c,
795 0x91, 0x57, 0x06, 0xe5, 0x56, 0xb4, 0xee, 0x0d, 0x31, 0xf2, 0xbf, 0xcb, 0x0d, 0x0a, 0x15, 0xdf,
796 0x4e, 0x33, 0x7e, 0xb5, 0x24, 0xb4, 0x2f, 0x5b, 0x6c, 0xf4, 0x98, 0x6c, 0x7a, 0x04, 0x09, 0xd9,
797 0x80, 0xf1, 0x66, 0x30, 0xab, 0x45, 0x51, 0xaf, 0x0e, 0x35, 0x22, 0x07, 0x8d, 0xf6, 0x60, 0x2d,
798 0x10, 0x30, 0x1c, 0xd2, 0xa3, 0x1a, 0x8c, 0x11, 0xfe, 0x53, 0x7d, 0xd8, 0xca, 0xce, 0xfa, 0x61,
799 0xaf, 0x02, 0xcb, 0xc2, 0x00, 0x85, 0x05, 0xb7, 0xfc, 0xb5, 0x04, 0xcb, 0x59, 0x2d, 0x01, 0x1d,
800 0xf4, 0x59, 0xf1, 0x5e, 0x60, 0x7d, 0x1f, 0x7e, 0xe5, 0xfb, 0x5e, 0x82, 0xa3, 0xfd, 0x36, 0x29,
801 0x56, 0x64, 0x6c, 0x7d, 0x8a, 0x76, 0x9f, 0xa8, 0xc8, 0x6e, 0x70, 0x29, 0x16, 0xa7, 0xe8, 0x14,
802 0x4c, 0x34, 0x34, 0xab, 0xb6, 0x6d, 0x7c, 0x16, 0x6e, 0xf5, 0x51, 0x9a, 0xbf, 0x2f, 0xe4, 0x38,
803 0x42, 0xa0, 0x4b, 0x30, 0xc7, 0xf5, 0xd6, 0x89, 0x55, 0xf7, 0x1a, 0xfc, 0x45, 0xc4, 0x6a, 0x12,
804 0x4d, 0x9d, 0x1b, 0x5d, 0xe7, 0xb8, 0x47, 0x43, 0xfe, 0x53, 0x02, 0xf4, 0x3c, 0xdb, 0xc4, 0x49,
805 0x28, 0x6a, 0x8e, 0xc1, 0x57, 0xdc, 0xa0, 0xd0, 0x8a, 0xea, 0x74, 0xbb, 0x55, 0x29, 0xae, 0x6e,
806 0x5d, 0x0d, 0x84, 0x38, 0x3e, 0x67, 0xe0, 0x70, 0xd0, 0x06, 0x03, 0x55, 0x80, 0x43, 0xc3, 0x14,
807 0xc7, 0xe7, 0xe8, 0x22, 0x4c, 0xe9, 0x4d, 0x9f, 0x7a, 0xc4, 0xdd, 0xd6, 0x6d, 0x87, 0xf0, 0xc6,
808 0x34, 0xa1, 0x1e, 0x15, 0x3e, 0x4d, 0xad, 0x75, 0x9c, 0xe1, 0x04, 0x12, 0x29, 0x00, 0xac, 0xac,
809 0xa8, 0xa3, 0x31, 0x3b, 0x05, 0x6e, 0x67, 0x86, 0x3d, 0xd8, 0x66, 0x24, 0xc5, 0x1d, 0x08, 0xf9,
810 0x3e, 0x2c, 0x6c, 0x13, 0x77, 0xdf, 0xd0, 0xc9, 0xaa, 0xae, 0xdb, 0xbe, 0xe5, 0x85, 0xcb, 0x7a,
811 0x15, 0x8a, 0x11, 0x4c, 0x54, 0xde, 0x11, 0x61, 0xbf, 0x18, 0x71, 0xe1, 0x18, 0x13, 0x95, 0x7a,
812 0x2e, 0xb5, 0xd4, 0x7f, 0xca, 0xc1, 0x78, 0x4c, 0x9f, 0xdf, 0x33, 0xac, 0x9a, 0x60, 0x3e, 0x16,
813 0xa2, 0xaf, 0x19, 0x56, 0xed, 0x59, 0xab, 0x32, 0x29, 0x60, 0xec, 0x13, 0x73, 0x20, 0xba, 0x0a,
814 0x79, 0x9f, 0x12, 0x57, 0x14, 0xf1, 0xc9, 0xac, 0x64, 0xbe, 0x45, 0x89, 0x1b, 0xee, 0x57, 0x13,
815 0x8c, 0x99, 0x09, 0x30, 0xa7, 0x40, 0x1b, 0x50, 0xa8, 0xb3, 0x47, 0x11, 0x75, 0x7a, 0x2a, 0x8b,
816 0xab, 0xf3, 0x47, 0x4c, 0x90, 0x06, 0x5c, 0x82, 0x03, 0x16, 0xf4, 0x00, 0x66, 0x68, 0x22, 0x84,
817 0xfc, 0xb9, 0x86, 0xd8, 0x97, 0xfa, 0x06, 0x5e, 0x45, 0xed, 0x56, 0x65, 0x26, 0x79, 0x84, 0xbb,
818 0x0c, 0xc8, 0x55, 0x98, 0xec, 0x70, 0x30, 0xbb, 0xcb, 0xaa, 0x97, 0x1e, 0x3d, 0x2d, 0x8f, 0x3c,
819 0x7e, 0x5a, 0x1e, 0x79, 0xf2, 0xb4, 0x3c, 0xf2, 0x79, 0xbb, 0x2c, 0x3d, 0x6a, 0x97, 0xa5, 0xc7,
820 0xed, 0xb2, 0xf4, 0xa4, 0x5d, 0x96, 0x7e, 0x6d, 0x97, 0xa5, 0x2f, 0x7f, 0x2b, 0x8f, 0xdc, 0x29,
821 0x0f, 0xfe, 0x5f, 0xec, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe3, 0xd5, 0xd0, 0x62, 0xac, 0x15,
822 0x00, 0x00,
823 }
824
825 func (m *ExemptPriorityLevelConfiguration) Marshal() (dAtA []byte, err error) {
826 size := m.Size()
827 dAtA = make([]byte, size)
828 n, err := m.MarshalToSizedBuffer(dAtA[:size])
829 if err != nil {
830 return nil, err
831 }
832 return dAtA[:n], nil
833 }
834
835 func (m *ExemptPriorityLevelConfiguration) MarshalTo(dAtA []byte) (int, error) {
836 size := m.Size()
837 return m.MarshalToSizedBuffer(dAtA[:size])
838 }
839
840 func (m *ExemptPriorityLevelConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
841 i := len(dAtA)
842 _ = i
843 var l int
844 _ = l
845 if m.LendablePercent != nil {
846 i = encodeVarintGenerated(dAtA, i, uint64(*m.LendablePercent))
847 i--
848 dAtA[i] = 0x10
849 }
850 if m.NominalConcurrencyShares != nil {
851 i = encodeVarintGenerated(dAtA, i, uint64(*m.NominalConcurrencyShares))
852 i--
853 dAtA[i] = 0x8
854 }
855 return len(dAtA) - i, nil
856 }
857
858 func (m *FlowDistinguisherMethod) Marshal() (dAtA []byte, err error) {
859 size := m.Size()
860 dAtA = make([]byte, size)
861 n, err := m.MarshalToSizedBuffer(dAtA[:size])
862 if err != nil {
863 return nil, err
864 }
865 return dAtA[:n], nil
866 }
867
868 func (m *FlowDistinguisherMethod) MarshalTo(dAtA []byte) (int, error) {
869 size := m.Size()
870 return m.MarshalToSizedBuffer(dAtA[:size])
871 }
872
873 func (m *FlowDistinguisherMethod) MarshalToSizedBuffer(dAtA []byte) (int, error) {
874 i := len(dAtA)
875 _ = i
876 var l int
877 _ = l
878 i -= len(m.Type)
879 copy(dAtA[i:], m.Type)
880 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
881 i--
882 dAtA[i] = 0xa
883 return len(dAtA) - i, nil
884 }
885
886 func (m *FlowSchema) Marshal() (dAtA []byte, err error) {
887 size := m.Size()
888 dAtA = make([]byte, size)
889 n, err := m.MarshalToSizedBuffer(dAtA[:size])
890 if err != nil {
891 return nil, err
892 }
893 return dAtA[:n], nil
894 }
895
896 func (m *FlowSchema) MarshalTo(dAtA []byte) (int, error) {
897 size := m.Size()
898 return m.MarshalToSizedBuffer(dAtA[:size])
899 }
900
901 func (m *FlowSchema) MarshalToSizedBuffer(dAtA []byte) (int, error) {
902 i := len(dAtA)
903 _ = i
904 var l int
905 _ = l
906 {
907 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
908 if err != nil {
909 return 0, err
910 }
911 i -= size
912 i = encodeVarintGenerated(dAtA, i, uint64(size))
913 }
914 i--
915 dAtA[i] = 0x1a
916 {
917 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
918 if err != nil {
919 return 0, err
920 }
921 i -= size
922 i = encodeVarintGenerated(dAtA, i, uint64(size))
923 }
924 i--
925 dAtA[i] = 0x12
926 {
927 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
928 if err != nil {
929 return 0, err
930 }
931 i -= size
932 i = encodeVarintGenerated(dAtA, i, uint64(size))
933 }
934 i--
935 dAtA[i] = 0xa
936 return len(dAtA) - i, nil
937 }
938
939 func (m *FlowSchemaCondition) Marshal() (dAtA []byte, err error) {
940 size := m.Size()
941 dAtA = make([]byte, size)
942 n, err := m.MarshalToSizedBuffer(dAtA[:size])
943 if err != nil {
944 return nil, err
945 }
946 return dAtA[:n], nil
947 }
948
949 func (m *FlowSchemaCondition) MarshalTo(dAtA []byte) (int, error) {
950 size := m.Size()
951 return m.MarshalToSizedBuffer(dAtA[:size])
952 }
953
954 func (m *FlowSchemaCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
955 i := len(dAtA)
956 _ = i
957 var l int
958 _ = l
959 i -= len(m.Message)
960 copy(dAtA[i:], m.Message)
961 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
962 i--
963 dAtA[i] = 0x2a
964 i -= len(m.Reason)
965 copy(dAtA[i:], m.Reason)
966 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
967 i--
968 dAtA[i] = 0x22
969 {
970 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
971 if err != nil {
972 return 0, err
973 }
974 i -= size
975 i = encodeVarintGenerated(dAtA, i, uint64(size))
976 }
977 i--
978 dAtA[i] = 0x1a
979 i -= len(m.Status)
980 copy(dAtA[i:], m.Status)
981 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
982 i--
983 dAtA[i] = 0x12
984 i -= len(m.Type)
985 copy(dAtA[i:], m.Type)
986 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
987 i--
988 dAtA[i] = 0xa
989 return len(dAtA) - i, nil
990 }
991
992 func (m *FlowSchemaList) Marshal() (dAtA []byte, err error) {
993 size := m.Size()
994 dAtA = make([]byte, size)
995 n, err := m.MarshalToSizedBuffer(dAtA[:size])
996 if err != nil {
997 return nil, err
998 }
999 return dAtA[:n], nil
1000 }
1001
1002 func (m *FlowSchemaList) MarshalTo(dAtA []byte) (int, error) {
1003 size := m.Size()
1004 return m.MarshalToSizedBuffer(dAtA[:size])
1005 }
1006
1007 func (m *FlowSchemaList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1008 i := len(dAtA)
1009 _ = i
1010 var l int
1011 _ = l
1012 if len(m.Items) > 0 {
1013 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1014 {
1015 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1016 if err != nil {
1017 return 0, err
1018 }
1019 i -= size
1020 i = encodeVarintGenerated(dAtA, i, uint64(size))
1021 }
1022 i--
1023 dAtA[i] = 0x12
1024 }
1025 }
1026 {
1027 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1028 if err != nil {
1029 return 0, err
1030 }
1031 i -= size
1032 i = encodeVarintGenerated(dAtA, i, uint64(size))
1033 }
1034 i--
1035 dAtA[i] = 0xa
1036 return len(dAtA) - i, nil
1037 }
1038
1039 func (m *FlowSchemaSpec) Marshal() (dAtA []byte, err error) {
1040 size := m.Size()
1041 dAtA = make([]byte, size)
1042 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1043 if err != nil {
1044 return nil, err
1045 }
1046 return dAtA[:n], nil
1047 }
1048
1049 func (m *FlowSchemaSpec) MarshalTo(dAtA []byte) (int, error) {
1050 size := m.Size()
1051 return m.MarshalToSizedBuffer(dAtA[:size])
1052 }
1053
1054 func (m *FlowSchemaSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1055 i := len(dAtA)
1056 _ = i
1057 var l int
1058 _ = l
1059 if len(m.Rules) > 0 {
1060 for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
1061 {
1062 size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1063 if err != nil {
1064 return 0, err
1065 }
1066 i -= size
1067 i = encodeVarintGenerated(dAtA, i, uint64(size))
1068 }
1069 i--
1070 dAtA[i] = 0x22
1071 }
1072 }
1073 if m.DistinguisherMethod != nil {
1074 {
1075 size, err := m.DistinguisherMethod.MarshalToSizedBuffer(dAtA[:i])
1076 if err != nil {
1077 return 0, err
1078 }
1079 i -= size
1080 i = encodeVarintGenerated(dAtA, i, uint64(size))
1081 }
1082 i--
1083 dAtA[i] = 0x1a
1084 }
1085 i = encodeVarintGenerated(dAtA, i, uint64(m.MatchingPrecedence))
1086 i--
1087 dAtA[i] = 0x10
1088 {
1089 size, err := m.PriorityLevelConfiguration.MarshalToSizedBuffer(dAtA[:i])
1090 if err != nil {
1091 return 0, err
1092 }
1093 i -= size
1094 i = encodeVarintGenerated(dAtA, i, uint64(size))
1095 }
1096 i--
1097 dAtA[i] = 0xa
1098 return len(dAtA) - i, nil
1099 }
1100
1101 func (m *FlowSchemaStatus) Marshal() (dAtA []byte, err error) {
1102 size := m.Size()
1103 dAtA = make([]byte, size)
1104 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1105 if err != nil {
1106 return nil, err
1107 }
1108 return dAtA[:n], nil
1109 }
1110
1111 func (m *FlowSchemaStatus) MarshalTo(dAtA []byte) (int, error) {
1112 size := m.Size()
1113 return m.MarshalToSizedBuffer(dAtA[:size])
1114 }
1115
1116 func (m *FlowSchemaStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1117 i := len(dAtA)
1118 _ = i
1119 var l int
1120 _ = l
1121 if len(m.Conditions) > 0 {
1122 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1123 {
1124 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1125 if err != nil {
1126 return 0, err
1127 }
1128 i -= size
1129 i = encodeVarintGenerated(dAtA, i, uint64(size))
1130 }
1131 i--
1132 dAtA[i] = 0xa
1133 }
1134 }
1135 return len(dAtA) - i, nil
1136 }
1137
1138 func (m *GroupSubject) Marshal() (dAtA []byte, err error) {
1139 size := m.Size()
1140 dAtA = make([]byte, size)
1141 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1142 if err != nil {
1143 return nil, err
1144 }
1145 return dAtA[:n], nil
1146 }
1147
1148 func (m *GroupSubject) MarshalTo(dAtA []byte) (int, error) {
1149 size := m.Size()
1150 return m.MarshalToSizedBuffer(dAtA[:size])
1151 }
1152
1153 func (m *GroupSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1154 i := len(dAtA)
1155 _ = i
1156 var l int
1157 _ = l
1158 i -= len(m.Name)
1159 copy(dAtA[i:], m.Name)
1160 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1161 i--
1162 dAtA[i] = 0xa
1163 return len(dAtA) - i, nil
1164 }
1165
1166 func (m *LimitResponse) Marshal() (dAtA []byte, err error) {
1167 size := m.Size()
1168 dAtA = make([]byte, size)
1169 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1170 if err != nil {
1171 return nil, err
1172 }
1173 return dAtA[:n], nil
1174 }
1175
1176 func (m *LimitResponse) MarshalTo(dAtA []byte) (int, error) {
1177 size := m.Size()
1178 return m.MarshalToSizedBuffer(dAtA[:size])
1179 }
1180
1181 func (m *LimitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1182 i := len(dAtA)
1183 _ = i
1184 var l int
1185 _ = l
1186 if m.Queuing != nil {
1187 {
1188 size, err := m.Queuing.MarshalToSizedBuffer(dAtA[:i])
1189 if err != nil {
1190 return 0, err
1191 }
1192 i -= size
1193 i = encodeVarintGenerated(dAtA, i, uint64(size))
1194 }
1195 i--
1196 dAtA[i] = 0x12
1197 }
1198 i -= len(m.Type)
1199 copy(dAtA[i:], m.Type)
1200 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1201 i--
1202 dAtA[i] = 0xa
1203 return len(dAtA) - i, nil
1204 }
1205
1206 func (m *LimitedPriorityLevelConfiguration) Marshal() (dAtA []byte, err error) {
1207 size := m.Size()
1208 dAtA = make([]byte, size)
1209 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1210 if err != nil {
1211 return nil, err
1212 }
1213 return dAtA[:n], nil
1214 }
1215
1216 func (m *LimitedPriorityLevelConfiguration) MarshalTo(dAtA []byte) (int, error) {
1217 size := m.Size()
1218 return m.MarshalToSizedBuffer(dAtA[:size])
1219 }
1220
1221 func (m *LimitedPriorityLevelConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1222 i := len(dAtA)
1223 _ = i
1224 var l int
1225 _ = l
1226 if m.BorrowingLimitPercent != nil {
1227 i = encodeVarintGenerated(dAtA, i, uint64(*m.BorrowingLimitPercent))
1228 i--
1229 dAtA[i] = 0x20
1230 }
1231 if m.LendablePercent != nil {
1232 i = encodeVarintGenerated(dAtA, i, uint64(*m.LendablePercent))
1233 i--
1234 dAtA[i] = 0x18
1235 }
1236 {
1237 size, err := m.LimitResponse.MarshalToSizedBuffer(dAtA[:i])
1238 if err != nil {
1239 return 0, err
1240 }
1241 i -= size
1242 i = encodeVarintGenerated(dAtA, i, uint64(size))
1243 }
1244 i--
1245 dAtA[i] = 0x12
1246 i = encodeVarintGenerated(dAtA, i, uint64(m.AssuredConcurrencyShares))
1247 i--
1248 dAtA[i] = 0x8
1249 return len(dAtA) - i, nil
1250 }
1251
1252 func (m *NonResourcePolicyRule) Marshal() (dAtA []byte, err error) {
1253 size := m.Size()
1254 dAtA = make([]byte, size)
1255 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1256 if err != nil {
1257 return nil, err
1258 }
1259 return dAtA[:n], nil
1260 }
1261
1262 func (m *NonResourcePolicyRule) MarshalTo(dAtA []byte) (int, error) {
1263 size := m.Size()
1264 return m.MarshalToSizedBuffer(dAtA[:size])
1265 }
1266
1267 func (m *NonResourcePolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1268 i := len(dAtA)
1269 _ = i
1270 var l int
1271 _ = l
1272 if len(m.NonResourceURLs) > 0 {
1273 for iNdEx := len(m.NonResourceURLs) - 1; iNdEx >= 0; iNdEx-- {
1274 i -= len(m.NonResourceURLs[iNdEx])
1275 copy(dAtA[i:], m.NonResourceURLs[iNdEx])
1276 i = encodeVarintGenerated(dAtA, i, uint64(len(m.NonResourceURLs[iNdEx])))
1277 i--
1278 dAtA[i] = 0x32
1279 }
1280 }
1281 if len(m.Verbs) > 0 {
1282 for iNdEx := len(m.Verbs) - 1; iNdEx >= 0; iNdEx-- {
1283 i -= len(m.Verbs[iNdEx])
1284 copy(dAtA[i:], m.Verbs[iNdEx])
1285 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verbs[iNdEx])))
1286 i--
1287 dAtA[i] = 0xa
1288 }
1289 }
1290 return len(dAtA) - i, nil
1291 }
1292
1293 func (m *PolicyRulesWithSubjects) Marshal() (dAtA []byte, err error) {
1294 size := m.Size()
1295 dAtA = make([]byte, size)
1296 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1297 if err != nil {
1298 return nil, err
1299 }
1300 return dAtA[:n], nil
1301 }
1302
1303 func (m *PolicyRulesWithSubjects) MarshalTo(dAtA []byte) (int, error) {
1304 size := m.Size()
1305 return m.MarshalToSizedBuffer(dAtA[:size])
1306 }
1307
1308 func (m *PolicyRulesWithSubjects) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1309 i := len(dAtA)
1310 _ = i
1311 var l int
1312 _ = l
1313 if len(m.NonResourceRules) > 0 {
1314 for iNdEx := len(m.NonResourceRules) - 1; iNdEx >= 0; iNdEx-- {
1315 {
1316 size, err := m.NonResourceRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1317 if err != nil {
1318 return 0, err
1319 }
1320 i -= size
1321 i = encodeVarintGenerated(dAtA, i, uint64(size))
1322 }
1323 i--
1324 dAtA[i] = 0x1a
1325 }
1326 }
1327 if len(m.ResourceRules) > 0 {
1328 for iNdEx := len(m.ResourceRules) - 1; iNdEx >= 0; iNdEx-- {
1329 {
1330 size, err := m.ResourceRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1331 if err != nil {
1332 return 0, err
1333 }
1334 i -= size
1335 i = encodeVarintGenerated(dAtA, i, uint64(size))
1336 }
1337 i--
1338 dAtA[i] = 0x12
1339 }
1340 }
1341 if len(m.Subjects) > 0 {
1342 for iNdEx := len(m.Subjects) - 1; iNdEx >= 0; iNdEx-- {
1343 {
1344 size, err := m.Subjects[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1345 if err != nil {
1346 return 0, err
1347 }
1348 i -= size
1349 i = encodeVarintGenerated(dAtA, i, uint64(size))
1350 }
1351 i--
1352 dAtA[i] = 0xa
1353 }
1354 }
1355 return len(dAtA) - i, nil
1356 }
1357
1358 func (m *PriorityLevelConfiguration) Marshal() (dAtA []byte, err error) {
1359 size := m.Size()
1360 dAtA = make([]byte, size)
1361 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1362 if err != nil {
1363 return nil, err
1364 }
1365 return dAtA[:n], nil
1366 }
1367
1368 func (m *PriorityLevelConfiguration) MarshalTo(dAtA []byte) (int, error) {
1369 size := m.Size()
1370 return m.MarshalToSizedBuffer(dAtA[:size])
1371 }
1372
1373 func (m *PriorityLevelConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1374 i := len(dAtA)
1375 _ = i
1376 var l int
1377 _ = l
1378 {
1379 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1380 if err != nil {
1381 return 0, err
1382 }
1383 i -= size
1384 i = encodeVarintGenerated(dAtA, i, uint64(size))
1385 }
1386 i--
1387 dAtA[i] = 0x1a
1388 {
1389 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1390 if err != nil {
1391 return 0, err
1392 }
1393 i -= size
1394 i = encodeVarintGenerated(dAtA, i, uint64(size))
1395 }
1396 i--
1397 dAtA[i] = 0x12
1398 {
1399 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1400 if err != nil {
1401 return 0, err
1402 }
1403 i -= size
1404 i = encodeVarintGenerated(dAtA, i, uint64(size))
1405 }
1406 i--
1407 dAtA[i] = 0xa
1408 return len(dAtA) - i, nil
1409 }
1410
1411 func (m *PriorityLevelConfigurationCondition) Marshal() (dAtA []byte, err error) {
1412 size := m.Size()
1413 dAtA = make([]byte, size)
1414 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1415 if err != nil {
1416 return nil, err
1417 }
1418 return dAtA[:n], nil
1419 }
1420
1421 func (m *PriorityLevelConfigurationCondition) MarshalTo(dAtA []byte) (int, error) {
1422 size := m.Size()
1423 return m.MarshalToSizedBuffer(dAtA[:size])
1424 }
1425
1426 func (m *PriorityLevelConfigurationCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1427 i := len(dAtA)
1428 _ = i
1429 var l int
1430 _ = l
1431 i -= len(m.Message)
1432 copy(dAtA[i:], m.Message)
1433 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1434 i--
1435 dAtA[i] = 0x2a
1436 i -= len(m.Reason)
1437 copy(dAtA[i:], m.Reason)
1438 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1439 i--
1440 dAtA[i] = 0x22
1441 {
1442 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1443 if err != nil {
1444 return 0, err
1445 }
1446 i -= size
1447 i = encodeVarintGenerated(dAtA, i, uint64(size))
1448 }
1449 i--
1450 dAtA[i] = 0x1a
1451 i -= len(m.Status)
1452 copy(dAtA[i:], m.Status)
1453 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1454 i--
1455 dAtA[i] = 0x12
1456 i -= len(m.Type)
1457 copy(dAtA[i:], m.Type)
1458 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1459 i--
1460 dAtA[i] = 0xa
1461 return len(dAtA) - i, nil
1462 }
1463
1464 func (m *PriorityLevelConfigurationList) Marshal() (dAtA []byte, err error) {
1465 size := m.Size()
1466 dAtA = make([]byte, size)
1467 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1468 if err != nil {
1469 return nil, err
1470 }
1471 return dAtA[:n], nil
1472 }
1473
1474 func (m *PriorityLevelConfigurationList) MarshalTo(dAtA []byte) (int, error) {
1475 size := m.Size()
1476 return m.MarshalToSizedBuffer(dAtA[:size])
1477 }
1478
1479 func (m *PriorityLevelConfigurationList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1480 i := len(dAtA)
1481 _ = i
1482 var l int
1483 _ = l
1484 if len(m.Items) > 0 {
1485 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1486 {
1487 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1488 if err != nil {
1489 return 0, err
1490 }
1491 i -= size
1492 i = encodeVarintGenerated(dAtA, i, uint64(size))
1493 }
1494 i--
1495 dAtA[i] = 0x12
1496 }
1497 }
1498 {
1499 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1500 if err != nil {
1501 return 0, err
1502 }
1503 i -= size
1504 i = encodeVarintGenerated(dAtA, i, uint64(size))
1505 }
1506 i--
1507 dAtA[i] = 0xa
1508 return len(dAtA) - i, nil
1509 }
1510
1511 func (m *PriorityLevelConfigurationReference) Marshal() (dAtA []byte, err error) {
1512 size := m.Size()
1513 dAtA = make([]byte, size)
1514 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1515 if err != nil {
1516 return nil, err
1517 }
1518 return dAtA[:n], nil
1519 }
1520
1521 func (m *PriorityLevelConfigurationReference) MarshalTo(dAtA []byte) (int, error) {
1522 size := m.Size()
1523 return m.MarshalToSizedBuffer(dAtA[:size])
1524 }
1525
1526 func (m *PriorityLevelConfigurationReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1527 i := len(dAtA)
1528 _ = i
1529 var l int
1530 _ = l
1531 i -= len(m.Name)
1532 copy(dAtA[i:], m.Name)
1533 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1534 i--
1535 dAtA[i] = 0xa
1536 return len(dAtA) - i, nil
1537 }
1538
1539 func (m *PriorityLevelConfigurationSpec) Marshal() (dAtA []byte, err error) {
1540 size := m.Size()
1541 dAtA = make([]byte, size)
1542 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1543 if err != nil {
1544 return nil, err
1545 }
1546 return dAtA[:n], nil
1547 }
1548
1549 func (m *PriorityLevelConfigurationSpec) MarshalTo(dAtA []byte) (int, error) {
1550 size := m.Size()
1551 return m.MarshalToSizedBuffer(dAtA[:size])
1552 }
1553
1554 func (m *PriorityLevelConfigurationSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1555 i := len(dAtA)
1556 _ = i
1557 var l int
1558 _ = l
1559 if m.Exempt != nil {
1560 {
1561 size, err := m.Exempt.MarshalToSizedBuffer(dAtA[:i])
1562 if err != nil {
1563 return 0, err
1564 }
1565 i -= size
1566 i = encodeVarintGenerated(dAtA, i, uint64(size))
1567 }
1568 i--
1569 dAtA[i] = 0x1a
1570 }
1571 if m.Limited != nil {
1572 {
1573 size, err := m.Limited.MarshalToSizedBuffer(dAtA[:i])
1574 if err != nil {
1575 return 0, err
1576 }
1577 i -= size
1578 i = encodeVarintGenerated(dAtA, i, uint64(size))
1579 }
1580 i--
1581 dAtA[i] = 0x12
1582 }
1583 i -= len(m.Type)
1584 copy(dAtA[i:], m.Type)
1585 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1586 i--
1587 dAtA[i] = 0xa
1588 return len(dAtA) - i, nil
1589 }
1590
1591 func (m *PriorityLevelConfigurationStatus) Marshal() (dAtA []byte, err error) {
1592 size := m.Size()
1593 dAtA = make([]byte, size)
1594 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1595 if err != nil {
1596 return nil, err
1597 }
1598 return dAtA[:n], nil
1599 }
1600
1601 func (m *PriorityLevelConfigurationStatus) MarshalTo(dAtA []byte) (int, error) {
1602 size := m.Size()
1603 return m.MarshalToSizedBuffer(dAtA[:size])
1604 }
1605
1606 func (m *PriorityLevelConfigurationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1607 i := len(dAtA)
1608 _ = i
1609 var l int
1610 _ = l
1611 if len(m.Conditions) > 0 {
1612 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1613 {
1614 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1615 if err != nil {
1616 return 0, err
1617 }
1618 i -= size
1619 i = encodeVarintGenerated(dAtA, i, uint64(size))
1620 }
1621 i--
1622 dAtA[i] = 0xa
1623 }
1624 }
1625 return len(dAtA) - i, nil
1626 }
1627
1628 func (m *QueuingConfiguration) Marshal() (dAtA []byte, err error) {
1629 size := m.Size()
1630 dAtA = make([]byte, size)
1631 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1632 if err != nil {
1633 return nil, err
1634 }
1635 return dAtA[:n], nil
1636 }
1637
1638 func (m *QueuingConfiguration) MarshalTo(dAtA []byte) (int, error) {
1639 size := m.Size()
1640 return m.MarshalToSizedBuffer(dAtA[:size])
1641 }
1642
1643 func (m *QueuingConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1644 i := len(dAtA)
1645 _ = i
1646 var l int
1647 _ = l
1648 i = encodeVarintGenerated(dAtA, i, uint64(m.QueueLengthLimit))
1649 i--
1650 dAtA[i] = 0x18
1651 i = encodeVarintGenerated(dAtA, i, uint64(m.HandSize))
1652 i--
1653 dAtA[i] = 0x10
1654 i = encodeVarintGenerated(dAtA, i, uint64(m.Queues))
1655 i--
1656 dAtA[i] = 0x8
1657 return len(dAtA) - i, nil
1658 }
1659
1660 func (m *ResourcePolicyRule) Marshal() (dAtA []byte, err error) {
1661 size := m.Size()
1662 dAtA = make([]byte, size)
1663 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1664 if err != nil {
1665 return nil, err
1666 }
1667 return dAtA[:n], nil
1668 }
1669
1670 func (m *ResourcePolicyRule) MarshalTo(dAtA []byte) (int, error) {
1671 size := m.Size()
1672 return m.MarshalToSizedBuffer(dAtA[:size])
1673 }
1674
1675 func (m *ResourcePolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1676 i := len(dAtA)
1677 _ = i
1678 var l int
1679 _ = l
1680 if len(m.Namespaces) > 0 {
1681 for iNdEx := len(m.Namespaces) - 1; iNdEx >= 0; iNdEx-- {
1682 i -= len(m.Namespaces[iNdEx])
1683 copy(dAtA[i:], m.Namespaces[iNdEx])
1684 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespaces[iNdEx])))
1685 i--
1686 dAtA[i] = 0x2a
1687 }
1688 }
1689 i--
1690 if m.ClusterScope {
1691 dAtA[i] = 1
1692 } else {
1693 dAtA[i] = 0
1694 }
1695 i--
1696 dAtA[i] = 0x20
1697 if len(m.Resources) > 0 {
1698 for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
1699 i -= len(m.Resources[iNdEx])
1700 copy(dAtA[i:], m.Resources[iNdEx])
1701 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resources[iNdEx])))
1702 i--
1703 dAtA[i] = 0x1a
1704 }
1705 }
1706 if len(m.APIGroups) > 0 {
1707 for iNdEx := len(m.APIGroups) - 1; iNdEx >= 0; iNdEx-- {
1708 i -= len(m.APIGroups[iNdEx])
1709 copy(dAtA[i:], m.APIGroups[iNdEx])
1710 i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroups[iNdEx])))
1711 i--
1712 dAtA[i] = 0x12
1713 }
1714 }
1715 if len(m.Verbs) > 0 {
1716 for iNdEx := len(m.Verbs) - 1; iNdEx >= 0; iNdEx-- {
1717 i -= len(m.Verbs[iNdEx])
1718 copy(dAtA[i:], m.Verbs[iNdEx])
1719 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verbs[iNdEx])))
1720 i--
1721 dAtA[i] = 0xa
1722 }
1723 }
1724 return len(dAtA) - i, nil
1725 }
1726
1727 func (m *ServiceAccountSubject) Marshal() (dAtA []byte, err error) {
1728 size := m.Size()
1729 dAtA = make([]byte, size)
1730 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1731 if err != nil {
1732 return nil, err
1733 }
1734 return dAtA[:n], nil
1735 }
1736
1737 func (m *ServiceAccountSubject) MarshalTo(dAtA []byte) (int, error) {
1738 size := m.Size()
1739 return m.MarshalToSizedBuffer(dAtA[:size])
1740 }
1741
1742 func (m *ServiceAccountSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1743 i := len(dAtA)
1744 _ = i
1745 var l int
1746 _ = l
1747 i -= len(m.Name)
1748 copy(dAtA[i:], m.Name)
1749 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1750 i--
1751 dAtA[i] = 0x12
1752 i -= len(m.Namespace)
1753 copy(dAtA[i:], m.Namespace)
1754 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
1755 i--
1756 dAtA[i] = 0xa
1757 return len(dAtA) - i, nil
1758 }
1759
1760 func (m *Subject) Marshal() (dAtA []byte, err error) {
1761 size := m.Size()
1762 dAtA = make([]byte, size)
1763 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1764 if err != nil {
1765 return nil, err
1766 }
1767 return dAtA[:n], nil
1768 }
1769
1770 func (m *Subject) MarshalTo(dAtA []byte) (int, error) {
1771 size := m.Size()
1772 return m.MarshalToSizedBuffer(dAtA[:size])
1773 }
1774
1775 func (m *Subject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1776 i := len(dAtA)
1777 _ = i
1778 var l int
1779 _ = l
1780 if m.ServiceAccount != nil {
1781 {
1782 size, err := m.ServiceAccount.MarshalToSizedBuffer(dAtA[:i])
1783 if err != nil {
1784 return 0, err
1785 }
1786 i -= size
1787 i = encodeVarintGenerated(dAtA, i, uint64(size))
1788 }
1789 i--
1790 dAtA[i] = 0x22
1791 }
1792 if m.Group != nil {
1793 {
1794 size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
1795 if err != nil {
1796 return 0, err
1797 }
1798 i -= size
1799 i = encodeVarintGenerated(dAtA, i, uint64(size))
1800 }
1801 i--
1802 dAtA[i] = 0x1a
1803 }
1804 if m.User != nil {
1805 {
1806 size, err := m.User.MarshalToSizedBuffer(dAtA[:i])
1807 if err != nil {
1808 return 0, err
1809 }
1810 i -= size
1811 i = encodeVarintGenerated(dAtA, i, uint64(size))
1812 }
1813 i--
1814 dAtA[i] = 0x12
1815 }
1816 i -= len(m.Kind)
1817 copy(dAtA[i:], m.Kind)
1818 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1819 i--
1820 dAtA[i] = 0xa
1821 return len(dAtA) - i, nil
1822 }
1823
1824 func (m *UserSubject) Marshal() (dAtA []byte, err error) {
1825 size := m.Size()
1826 dAtA = make([]byte, size)
1827 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1828 if err != nil {
1829 return nil, err
1830 }
1831 return dAtA[:n], nil
1832 }
1833
1834 func (m *UserSubject) MarshalTo(dAtA []byte) (int, error) {
1835 size := m.Size()
1836 return m.MarshalToSizedBuffer(dAtA[:size])
1837 }
1838
1839 func (m *UserSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1840 i := len(dAtA)
1841 _ = i
1842 var l int
1843 _ = l
1844 i -= len(m.Name)
1845 copy(dAtA[i:], m.Name)
1846 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1847 i--
1848 dAtA[i] = 0xa
1849 return len(dAtA) - i, nil
1850 }
1851
1852 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1853 offset -= sovGenerated(v)
1854 base := offset
1855 for v >= 1<<7 {
1856 dAtA[offset] = uint8(v&0x7f | 0x80)
1857 v >>= 7
1858 offset++
1859 }
1860 dAtA[offset] = uint8(v)
1861 return base
1862 }
1863 func (m *ExemptPriorityLevelConfiguration) Size() (n int) {
1864 if m == nil {
1865 return 0
1866 }
1867 var l int
1868 _ = l
1869 if m.NominalConcurrencyShares != nil {
1870 n += 1 + sovGenerated(uint64(*m.NominalConcurrencyShares))
1871 }
1872 if m.LendablePercent != nil {
1873 n += 1 + sovGenerated(uint64(*m.LendablePercent))
1874 }
1875 return n
1876 }
1877
1878 func (m *FlowDistinguisherMethod) Size() (n int) {
1879 if m == nil {
1880 return 0
1881 }
1882 var l int
1883 _ = l
1884 l = len(m.Type)
1885 n += 1 + l + sovGenerated(uint64(l))
1886 return n
1887 }
1888
1889 func (m *FlowSchema) Size() (n int) {
1890 if m == nil {
1891 return 0
1892 }
1893 var l int
1894 _ = l
1895 l = m.ObjectMeta.Size()
1896 n += 1 + l + sovGenerated(uint64(l))
1897 l = m.Spec.Size()
1898 n += 1 + l + sovGenerated(uint64(l))
1899 l = m.Status.Size()
1900 n += 1 + l + sovGenerated(uint64(l))
1901 return n
1902 }
1903
1904 func (m *FlowSchemaCondition) Size() (n int) {
1905 if m == nil {
1906 return 0
1907 }
1908 var l int
1909 _ = l
1910 l = len(m.Type)
1911 n += 1 + l + sovGenerated(uint64(l))
1912 l = len(m.Status)
1913 n += 1 + l + sovGenerated(uint64(l))
1914 l = m.LastTransitionTime.Size()
1915 n += 1 + l + sovGenerated(uint64(l))
1916 l = len(m.Reason)
1917 n += 1 + l + sovGenerated(uint64(l))
1918 l = len(m.Message)
1919 n += 1 + l + sovGenerated(uint64(l))
1920 return n
1921 }
1922
1923 func (m *FlowSchemaList) Size() (n int) {
1924 if m == nil {
1925 return 0
1926 }
1927 var l int
1928 _ = l
1929 l = m.ListMeta.Size()
1930 n += 1 + l + sovGenerated(uint64(l))
1931 if len(m.Items) > 0 {
1932 for _, e := range m.Items {
1933 l = e.Size()
1934 n += 1 + l + sovGenerated(uint64(l))
1935 }
1936 }
1937 return n
1938 }
1939
1940 func (m *FlowSchemaSpec) Size() (n int) {
1941 if m == nil {
1942 return 0
1943 }
1944 var l int
1945 _ = l
1946 l = m.PriorityLevelConfiguration.Size()
1947 n += 1 + l + sovGenerated(uint64(l))
1948 n += 1 + sovGenerated(uint64(m.MatchingPrecedence))
1949 if m.DistinguisherMethod != nil {
1950 l = m.DistinguisherMethod.Size()
1951 n += 1 + l + sovGenerated(uint64(l))
1952 }
1953 if len(m.Rules) > 0 {
1954 for _, e := range m.Rules {
1955 l = e.Size()
1956 n += 1 + l + sovGenerated(uint64(l))
1957 }
1958 }
1959 return n
1960 }
1961
1962 func (m *FlowSchemaStatus) Size() (n int) {
1963 if m == nil {
1964 return 0
1965 }
1966 var l int
1967 _ = l
1968 if len(m.Conditions) > 0 {
1969 for _, e := range m.Conditions {
1970 l = e.Size()
1971 n += 1 + l + sovGenerated(uint64(l))
1972 }
1973 }
1974 return n
1975 }
1976
1977 func (m *GroupSubject) Size() (n int) {
1978 if m == nil {
1979 return 0
1980 }
1981 var l int
1982 _ = l
1983 l = len(m.Name)
1984 n += 1 + l + sovGenerated(uint64(l))
1985 return n
1986 }
1987
1988 func (m *LimitResponse) Size() (n int) {
1989 if m == nil {
1990 return 0
1991 }
1992 var l int
1993 _ = l
1994 l = len(m.Type)
1995 n += 1 + l + sovGenerated(uint64(l))
1996 if m.Queuing != nil {
1997 l = m.Queuing.Size()
1998 n += 1 + l + sovGenerated(uint64(l))
1999 }
2000 return n
2001 }
2002
2003 func (m *LimitedPriorityLevelConfiguration) Size() (n int) {
2004 if m == nil {
2005 return 0
2006 }
2007 var l int
2008 _ = l
2009 n += 1 + sovGenerated(uint64(m.AssuredConcurrencyShares))
2010 l = m.LimitResponse.Size()
2011 n += 1 + l + sovGenerated(uint64(l))
2012 if m.LendablePercent != nil {
2013 n += 1 + sovGenerated(uint64(*m.LendablePercent))
2014 }
2015 if m.BorrowingLimitPercent != nil {
2016 n += 1 + sovGenerated(uint64(*m.BorrowingLimitPercent))
2017 }
2018 return n
2019 }
2020
2021 func (m *NonResourcePolicyRule) Size() (n int) {
2022 if m == nil {
2023 return 0
2024 }
2025 var l int
2026 _ = l
2027 if len(m.Verbs) > 0 {
2028 for _, s := range m.Verbs {
2029 l = len(s)
2030 n += 1 + l + sovGenerated(uint64(l))
2031 }
2032 }
2033 if len(m.NonResourceURLs) > 0 {
2034 for _, s := range m.NonResourceURLs {
2035 l = len(s)
2036 n += 1 + l + sovGenerated(uint64(l))
2037 }
2038 }
2039 return n
2040 }
2041
2042 func (m *PolicyRulesWithSubjects) Size() (n int) {
2043 if m == nil {
2044 return 0
2045 }
2046 var l int
2047 _ = l
2048 if len(m.Subjects) > 0 {
2049 for _, e := range m.Subjects {
2050 l = e.Size()
2051 n += 1 + l + sovGenerated(uint64(l))
2052 }
2053 }
2054 if len(m.ResourceRules) > 0 {
2055 for _, e := range m.ResourceRules {
2056 l = e.Size()
2057 n += 1 + l + sovGenerated(uint64(l))
2058 }
2059 }
2060 if len(m.NonResourceRules) > 0 {
2061 for _, e := range m.NonResourceRules {
2062 l = e.Size()
2063 n += 1 + l + sovGenerated(uint64(l))
2064 }
2065 }
2066 return n
2067 }
2068
2069 func (m *PriorityLevelConfiguration) Size() (n int) {
2070 if m == nil {
2071 return 0
2072 }
2073 var l int
2074 _ = l
2075 l = m.ObjectMeta.Size()
2076 n += 1 + l + sovGenerated(uint64(l))
2077 l = m.Spec.Size()
2078 n += 1 + l + sovGenerated(uint64(l))
2079 l = m.Status.Size()
2080 n += 1 + l + sovGenerated(uint64(l))
2081 return n
2082 }
2083
2084 func (m *PriorityLevelConfigurationCondition) Size() (n int) {
2085 if m == nil {
2086 return 0
2087 }
2088 var l int
2089 _ = l
2090 l = len(m.Type)
2091 n += 1 + l + sovGenerated(uint64(l))
2092 l = len(m.Status)
2093 n += 1 + l + sovGenerated(uint64(l))
2094 l = m.LastTransitionTime.Size()
2095 n += 1 + l + sovGenerated(uint64(l))
2096 l = len(m.Reason)
2097 n += 1 + l + sovGenerated(uint64(l))
2098 l = len(m.Message)
2099 n += 1 + l + sovGenerated(uint64(l))
2100 return n
2101 }
2102
2103 func (m *PriorityLevelConfigurationList) Size() (n int) {
2104 if m == nil {
2105 return 0
2106 }
2107 var l int
2108 _ = l
2109 l = m.ListMeta.Size()
2110 n += 1 + l + sovGenerated(uint64(l))
2111 if len(m.Items) > 0 {
2112 for _, e := range m.Items {
2113 l = e.Size()
2114 n += 1 + l + sovGenerated(uint64(l))
2115 }
2116 }
2117 return n
2118 }
2119
2120 func (m *PriorityLevelConfigurationReference) Size() (n int) {
2121 if m == nil {
2122 return 0
2123 }
2124 var l int
2125 _ = l
2126 l = len(m.Name)
2127 n += 1 + l + sovGenerated(uint64(l))
2128 return n
2129 }
2130
2131 func (m *PriorityLevelConfigurationSpec) Size() (n int) {
2132 if m == nil {
2133 return 0
2134 }
2135 var l int
2136 _ = l
2137 l = len(m.Type)
2138 n += 1 + l + sovGenerated(uint64(l))
2139 if m.Limited != nil {
2140 l = m.Limited.Size()
2141 n += 1 + l + sovGenerated(uint64(l))
2142 }
2143 if m.Exempt != nil {
2144 l = m.Exempt.Size()
2145 n += 1 + l + sovGenerated(uint64(l))
2146 }
2147 return n
2148 }
2149
2150 func (m *PriorityLevelConfigurationStatus) Size() (n int) {
2151 if m == nil {
2152 return 0
2153 }
2154 var l int
2155 _ = l
2156 if len(m.Conditions) > 0 {
2157 for _, e := range m.Conditions {
2158 l = e.Size()
2159 n += 1 + l + sovGenerated(uint64(l))
2160 }
2161 }
2162 return n
2163 }
2164
2165 func (m *QueuingConfiguration) Size() (n int) {
2166 if m == nil {
2167 return 0
2168 }
2169 var l int
2170 _ = l
2171 n += 1 + sovGenerated(uint64(m.Queues))
2172 n += 1 + sovGenerated(uint64(m.HandSize))
2173 n += 1 + sovGenerated(uint64(m.QueueLengthLimit))
2174 return n
2175 }
2176
2177 func (m *ResourcePolicyRule) Size() (n int) {
2178 if m == nil {
2179 return 0
2180 }
2181 var l int
2182 _ = l
2183 if len(m.Verbs) > 0 {
2184 for _, s := range m.Verbs {
2185 l = len(s)
2186 n += 1 + l + sovGenerated(uint64(l))
2187 }
2188 }
2189 if len(m.APIGroups) > 0 {
2190 for _, s := range m.APIGroups {
2191 l = len(s)
2192 n += 1 + l + sovGenerated(uint64(l))
2193 }
2194 }
2195 if len(m.Resources) > 0 {
2196 for _, s := range m.Resources {
2197 l = len(s)
2198 n += 1 + l + sovGenerated(uint64(l))
2199 }
2200 }
2201 n += 2
2202 if len(m.Namespaces) > 0 {
2203 for _, s := range m.Namespaces {
2204 l = len(s)
2205 n += 1 + l + sovGenerated(uint64(l))
2206 }
2207 }
2208 return n
2209 }
2210
2211 func (m *ServiceAccountSubject) Size() (n int) {
2212 if m == nil {
2213 return 0
2214 }
2215 var l int
2216 _ = l
2217 l = len(m.Namespace)
2218 n += 1 + l + sovGenerated(uint64(l))
2219 l = len(m.Name)
2220 n += 1 + l + sovGenerated(uint64(l))
2221 return n
2222 }
2223
2224 func (m *Subject) Size() (n int) {
2225 if m == nil {
2226 return 0
2227 }
2228 var l int
2229 _ = l
2230 l = len(m.Kind)
2231 n += 1 + l + sovGenerated(uint64(l))
2232 if m.User != nil {
2233 l = m.User.Size()
2234 n += 1 + l + sovGenerated(uint64(l))
2235 }
2236 if m.Group != nil {
2237 l = m.Group.Size()
2238 n += 1 + l + sovGenerated(uint64(l))
2239 }
2240 if m.ServiceAccount != nil {
2241 l = m.ServiceAccount.Size()
2242 n += 1 + l + sovGenerated(uint64(l))
2243 }
2244 return n
2245 }
2246
2247 func (m *UserSubject) Size() (n int) {
2248 if m == nil {
2249 return 0
2250 }
2251 var l int
2252 _ = l
2253 l = len(m.Name)
2254 n += 1 + l + sovGenerated(uint64(l))
2255 return n
2256 }
2257
2258 func sovGenerated(x uint64) (n int) {
2259 return (math_bits.Len64(x|1) + 6) / 7
2260 }
2261 func sozGenerated(x uint64) (n int) {
2262 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2263 }
2264 func (this *ExemptPriorityLevelConfiguration) String() string {
2265 if this == nil {
2266 return "nil"
2267 }
2268 s := strings.Join([]string{`&ExemptPriorityLevelConfiguration{`,
2269 `NominalConcurrencyShares:` + valueToStringGenerated(this.NominalConcurrencyShares) + `,`,
2270 `LendablePercent:` + valueToStringGenerated(this.LendablePercent) + `,`,
2271 `}`,
2272 }, "")
2273 return s
2274 }
2275 func (this *FlowDistinguisherMethod) String() string {
2276 if this == nil {
2277 return "nil"
2278 }
2279 s := strings.Join([]string{`&FlowDistinguisherMethod{`,
2280 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2281 `}`,
2282 }, "")
2283 return s
2284 }
2285 func (this *FlowSchema) String() string {
2286 if this == nil {
2287 return "nil"
2288 }
2289 s := strings.Join([]string{`&FlowSchema{`,
2290 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2291 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "FlowSchemaSpec", "FlowSchemaSpec", 1), `&`, ``, 1) + `,`,
2292 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "FlowSchemaStatus", "FlowSchemaStatus", 1), `&`, ``, 1) + `,`,
2293 `}`,
2294 }, "")
2295 return s
2296 }
2297 func (this *FlowSchemaCondition) String() string {
2298 if this == nil {
2299 return "nil"
2300 }
2301 s := strings.Join([]string{`&FlowSchemaCondition{`,
2302 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2303 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2304 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
2305 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2306 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2307 `}`,
2308 }, "")
2309 return s
2310 }
2311 func (this *FlowSchemaList) String() string {
2312 if this == nil {
2313 return "nil"
2314 }
2315 repeatedStringForItems := "[]FlowSchema{"
2316 for _, f := range this.Items {
2317 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "FlowSchema", "FlowSchema", 1), `&`, ``, 1) + ","
2318 }
2319 repeatedStringForItems += "}"
2320 s := strings.Join([]string{`&FlowSchemaList{`,
2321 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2322 `Items:` + repeatedStringForItems + `,`,
2323 `}`,
2324 }, "")
2325 return s
2326 }
2327 func (this *FlowSchemaSpec) String() string {
2328 if this == nil {
2329 return "nil"
2330 }
2331 repeatedStringForRules := "[]PolicyRulesWithSubjects{"
2332 for _, f := range this.Rules {
2333 repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "PolicyRulesWithSubjects", "PolicyRulesWithSubjects", 1), `&`, ``, 1) + ","
2334 }
2335 repeatedStringForRules += "}"
2336 s := strings.Join([]string{`&FlowSchemaSpec{`,
2337 `PriorityLevelConfiguration:` + strings.Replace(strings.Replace(this.PriorityLevelConfiguration.String(), "PriorityLevelConfigurationReference", "PriorityLevelConfigurationReference", 1), `&`, ``, 1) + `,`,
2338 `MatchingPrecedence:` + fmt.Sprintf("%v", this.MatchingPrecedence) + `,`,
2339 `DistinguisherMethod:` + strings.Replace(this.DistinguisherMethod.String(), "FlowDistinguisherMethod", "FlowDistinguisherMethod", 1) + `,`,
2340 `Rules:` + repeatedStringForRules + `,`,
2341 `}`,
2342 }, "")
2343 return s
2344 }
2345 func (this *FlowSchemaStatus) String() string {
2346 if this == nil {
2347 return "nil"
2348 }
2349 repeatedStringForConditions := "[]FlowSchemaCondition{"
2350 for _, f := range this.Conditions {
2351 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "FlowSchemaCondition", "FlowSchemaCondition", 1), `&`, ``, 1) + ","
2352 }
2353 repeatedStringForConditions += "}"
2354 s := strings.Join([]string{`&FlowSchemaStatus{`,
2355 `Conditions:` + repeatedStringForConditions + `,`,
2356 `}`,
2357 }, "")
2358 return s
2359 }
2360 func (this *GroupSubject) String() string {
2361 if this == nil {
2362 return "nil"
2363 }
2364 s := strings.Join([]string{`&GroupSubject{`,
2365 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2366 `}`,
2367 }, "")
2368 return s
2369 }
2370 func (this *LimitResponse) String() string {
2371 if this == nil {
2372 return "nil"
2373 }
2374 s := strings.Join([]string{`&LimitResponse{`,
2375 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2376 `Queuing:` + strings.Replace(this.Queuing.String(), "QueuingConfiguration", "QueuingConfiguration", 1) + `,`,
2377 `}`,
2378 }, "")
2379 return s
2380 }
2381 func (this *LimitedPriorityLevelConfiguration) String() string {
2382 if this == nil {
2383 return "nil"
2384 }
2385 s := strings.Join([]string{`&LimitedPriorityLevelConfiguration{`,
2386 `AssuredConcurrencyShares:` + fmt.Sprintf("%v", this.AssuredConcurrencyShares) + `,`,
2387 `LimitResponse:` + strings.Replace(strings.Replace(this.LimitResponse.String(), "LimitResponse", "LimitResponse", 1), `&`, ``, 1) + `,`,
2388 `LendablePercent:` + valueToStringGenerated(this.LendablePercent) + `,`,
2389 `BorrowingLimitPercent:` + valueToStringGenerated(this.BorrowingLimitPercent) + `,`,
2390 `}`,
2391 }, "")
2392 return s
2393 }
2394 func (this *NonResourcePolicyRule) String() string {
2395 if this == nil {
2396 return "nil"
2397 }
2398 s := strings.Join([]string{`&NonResourcePolicyRule{`,
2399 `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`,
2400 `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`,
2401 `}`,
2402 }, "")
2403 return s
2404 }
2405 func (this *PolicyRulesWithSubjects) String() string {
2406 if this == nil {
2407 return "nil"
2408 }
2409 repeatedStringForSubjects := "[]Subject{"
2410 for _, f := range this.Subjects {
2411 repeatedStringForSubjects += strings.Replace(strings.Replace(f.String(), "Subject", "Subject", 1), `&`, ``, 1) + ","
2412 }
2413 repeatedStringForSubjects += "}"
2414 repeatedStringForResourceRules := "[]ResourcePolicyRule{"
2415 for _, f := range this.ResourceRules {
2416 repeatedStringForResourceRules += strings.Replace(strings.Replace(f.String(), "ResourcePolicyRule", "ResourcePolicyRule", 1), `&`, ``, 1) + ","
2417 }
2418 repeatedStringForResourceRules += "}"
2419 repeatedStringForNonResourceRules := "[]NonResourcePolicyRule{"
2420 for _, f := range this.NonResourceRules {
2421 repeatedStringForNonResourceRules += strings.Replace(strings.Replace(f.String(), "NonResourcePolicyRule", "NonResourcePolicyRule", 1), `&`, ``, 1) + ","
2422 }
2423 repeatedStringForNonResourceRules += "}"
2424 s := strings.Join([]string{`&PolicyRulesWithSubjects{`,
2425 `Subjects:` + repeatedStringForSubjects + `,`,
2426 `ResourceRules:` + repeatedStringForResourceRules + `,`,
2427 `NonResourceRules:` + repeatedStringForNonResourceRules + `,`,
2428 `}`,
2429 }, "")
2430 return s
2431 }
2432 func (this *PriorityLevelConfiguration) String() string {
2433 if this == nil {
2434 return "nil"
2435 }
2436 s := strings.Join([]string{`&PriorityLevelConfiguration{`,
2437 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2438 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PriorityLevelConfigurationSpec", "PriorityLevelConfigurationSpec", 1), `&`, ``, 1) + `,`,
2439 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PriorityLevelConfigurationStatus", "PriorityLevelConfigurationStatus", 1), `&`, ``, 1) + `,`,
2440 `}`,
2441 }, "")
2442 return s
2443 }
2444 func (this *PriorityLevelConfigurationCondition) String() string {
2445 if this == nil {
2446 return "nil"
2447 }
2448 s := strings.Join([]string{`&PriorityLevelConfigurationCondition{`,
2449 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2450 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2451 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
2452 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2453 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2454 `}`,
2455 }, "")
2456 return s
2457 }
2458 func (this *PriorityLevelConfigurationList) String() string {
2459 if this == nil {
2460 return "nil"
2461 }
2462 repeatedStringForItems := "[]PriorityLevelConfiguration{"
2463 for _, f := range this.Items {
2464 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "PriorityLevelConfiguration", "PriorityLevelConfiguration", 1), `&`, ``, 1) + ","
2465 }
2466 repeatedStringForItems += "}"
2467 s := strings.Join([]string{`&PriorityLevelConfigurationList{`,
2468 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2469 `Items:` + repeatedStringForItems + `,`,
2470 `}`,
2471 }, "")
2472 return s
2473 }
2474 func (this *PriorityLevelConfigurationReference) String() string {
2475 if this == nil {
2476 return "nil"
2477 }
2478 s := strings.Join([]string{`&PriorityLevelConfigurationReference{`,
2479 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2480 `}`,
2481 }, "")
2482 return s
2483 }
2484 func (this *PriorityLevelConfigurationSpec) String() string {
2485 if this == nil {
2486 return "nil"
2487 }
2488 s := strings.Join([]string{`&PriorityLevelConfigurationSpec{`,
2489 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2490 `Limited:` + strings.Replace(this.Limited.String(), "LimitedPriorityLevelConfiguration", "LimitedPriorityLevelConfiguration", 1) + `,`,
2491 `Exempt:` + strings.Replace(this.Exempt.String(), "ExemptPriorityLevelConfiguration", "ExemptPriorityLevelConfiguration", 1) + `,`,
2492 `}`,
2493 }, "")
2494 return s
2495 }
2496 func (this *PriorityLevelConfigurationStatus) String() string {
2497 if this == nil {
2498 return "nil"
2499 }
2500 repeatedStringForConditions := "[]PriorityLevelConfigurationCondition{"
2501 for _, f := range this.Conditions {
2502 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "PriorityLevelConfigurationCondition", "PriorityLevelConfigurationCondition", 1), `&`, ``, 1) + ","
2503 }
2504 repeatedStringForConditions += "}"
2505 s := strings.Join([]string{`&PriorityLevelConfigurationStatus{`,
2506 `Conditions:` + repeatedStringForConditions + `,`,
2507 `}`,
2508 }, "")
2509 return s
2510 }
2511 func (this *QueuingConfiguration) String() string {
2512 if this == nil {
2513 return "nil"
2514 }
2515 s := strings.Join([]string{`&QueuingConfiguration{`,
2516 `Queues:` + fmt.Sprintf("%v", this.Queues) + `,`,
2517 `HandSize:` + fmt.Sprintf("%v", this.HandSize) + `,`,
2518 `QueueLengthLimit:` + fmt.Sprintf("%v", this.QueueLengthLimit) + `,`,
2519 `}`,
2520 }, "")
2521 return s
2522 }
2523 func (this *ResourcePolicyRule) String() string {
2524 if this == nil {
2525 return "nil"
2526 }
2527 s := strings.Join([]string{`&ResourcePolicyRule{`,
2528 `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`,
2529 `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
2530 `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
2531 `ClusterScope:` + fmt.Sprintf("%v", this.ClusterScope) + `,`,
2532 `Namespaces:` + fmt.Sprintf("%v", this.Namespaces) + `,`,
2533 `}`,
2534 }, "")
2535 return s
2536 }
2537 func (this *ServiceAccountSubject) String() string {
2538 if this == nil {
2539 return "nil"
2540 }
2541 s := strings.Join([]string{`&ServiceAccountSubject{`,
2542 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
2543 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2544 `}`,
2545 }, "")
2546 return s
2547 }
2548 func (this *Subject) String() string {
2549 if this == nil {
2550 return "nil"
2551 }
2552 s := strings.Join([]string{`&Subject{`,
2553 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2554 `User:` + strings.Replace(this.User.String(), "UserSubject", "UserSubject", 1) + `,`,
2555 `Group:` + strings.Replace(this.Group.String(), "GroupSubject", "GroupSubject", 1) + `,`,
2556 `ServiceAccount:` + strings.Replace(this.ServiceAccount.String(), "ServiceAccountSubject", "ServiceAccountSubject", 1) + `,`,
2557 `}`,
2558 }, "")
2559 return s
2560 }
2561 func (this *UserSubject) String() string {
2562 if this == nil {
2563 return "nil"
2564 }
2565 s := strings.Join([]string{`&UserSubject{`,
2566 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2567 `}`,
2568 }, "")
2569 return s
2570 }
2571 func valueToStringGenerated(v interface{}) string {
2572 rv := reflect.ValueOf(v)
2573 if rv.IsNil() {
2574 return "nil"
2575 }
2576 pv := reflect.Indirect(rv).Interface()
2577 return fmt.Sprintf("*%v", pv)
2578 }
2579 func (m *ExemptPriorityLevelConfiguration) Unmarshal(dAtA []byte) error {
2580 l := len(dAtA)
2581 iNdEx := 0
2582 for iNdEx < l {
2583 preIndex := iNdEx
2584 var wire uint64
2585 for shift := uint(0); ; shift += 7 {
2586 if shift >= 64 {
2587 return ErrIntOverflowGenerated
2588 }
2589 if iNdEx >= l {
2590 return io.ErrUnexpectedEOF
2591 }
2592 b := dAtA[iNdEx]
2593 iNdEx++
2594 wire |= uint64(b&0x7F) << shift
2595 if b < 0x80 {
2596 break
2597 }
2598 }
2599 fieldNum := int32(wire >> 3)
2600 wireType := int(wire & 0x7)
2601 if wireType == 4 {
2602 return fmt.Errorf("proto: ExemptPriorityLevelConfiguration: wiretype end group for non-group")
2603 }
2604 if fieldNum <= 0 {
2605 return fmt.Errorf("proto: ExemptPriorityLevelConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
2606 }
2607 switch fieldNum {
2608 case 1:
2609 if wireType != 0 {
2610 return fmt.Errorf("proto: wrong wireType = %d for field NominalConcurrencyShares", wireType)
2611 }
2612 var v int32
2613 for shift := uint(0); ; shift += 7 {
2614 if shift >= 64 {
2615 return ErrIntOverflowGenerated
2616 }
2617 if iNdEx >= l {
2618 return io.ErrUnexpectedEOF
2619 }
2620 b := dAtA[iNdEx]
2621 iNdEx++
2622 v |= int32(b&0x7F) << shift
2623 if b < 0x80 {
2624 break
2625 }
2626 }
2627 m.NominalConcurrencyShares = &v
2628 case 2:
2629 if wireType != 0 {
2630 return fmt.Errorf("proto: wrong wireType = %d for field LendablePercent", wireType)
2631 }
2632 var v int32
2633 for shift := uint(0); ; shift += 7 {
2634 if shift >= 64 {
2635 return ErrIntOverflowGenerated
2636 }
2637 if iNdEx >= l {
2638 return io.ErrUnexpectedEOF
2639 }
2640 b := dAtA[iNdEx]
2641 iNdEx++
2642 v |= int32(b&0x7F) << shift
2643 if b < 0x80 {
2644 break
2645 }
2646 }
2647 m.LendablePercent = &v
2648 default:
2649 iNdEx = preIndex
2650 skippy, err := skipGenerated(dAtA[iNdEx:])
2651 if err != nil {
2652 return err
2653 }
2654 if (skippy < 0) || (iNdEx+skippy) < 0 {
2655 return ErrInvalidLengthGenerated
2656 }
2657 if (iNdEx + skippy) > l {
2658 return io.ErrUnexpectedEOF
2659 }
2660 iNdEx += skippy
2661 }
2662 }
2663
2664 if iNdEx > l {
2665 return io.ErrUnexpectedEOF
2666 }
2667 return nil
2668 }
2669 func (m *FlowDistinguisherMethod) Unmarshal(dAtA []byte) error {
2670 l := len(dAtA)
2671 iNdEx := 0
2672 for iNdEx < l {
2673 preIndex := iNdEx
2674 var wire uint64
2675 for shift := uint(0); ; shift += 7 {
2676 if shift >= 64 {
2677 return ErrIntOverflowGenerated
2678 }
2679 if iNdEx >= l {
2680 return io.ErrUnexpectedEOF
2681 }
2682 b := dAtA[iNdEx]
2683 iNdEx++
2684 wire |= uint64(b&0x7F) << shift
2685 if b < 0x80 {
2686 break
2687 }
2688 }
2689 fieldNum := int32(wire >> 3)
2690 wireType := int(wire & 0x7)
2691 if wireType == 4 {
2692 return fmt.Errorf("proto: FlowDistinguisherMethod: wiretype end group for non-group")
2693 }
2694 if fieldNum <= 0 {
2695 return fmt.Errorf("proto: FlowDistinguisherMethod: illegal tag %d (wire type %d)", fieldNum, wire)
2696 }
2697 switch fieldNum {
2698 case 1:
2699 if wireType != 2 {
2700 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2701 }
2702 var stringLen uint64
2703 for shift := uint(0); ; shift += 7 {
2704 if shift >= 64 {
2705 return ErrIntOverflowGenerated
2706 }
2707 if iNdEx >= l {
2708 return io.ErrUnexpectedEOF
2709 }
2710 b := dAtA[iNdEx]
2711 iNdEx++
2712 stringLen |= uint64(b&0x7F) << shift
2713 if b < 0x80 {
2714 break
2715 }
2716 }
2717 intStringLen := int(stringLen)
2718 if intStringLen < 0 {
2719 return ErrInvalidLengthGenerated
2720 }
2721 postIndex := iNdEx + intStringLen
2722 if postIndex < 0 {
2723 return ErrInvalidLengthGenerated
2724 }
2725 if postIndex > l {
2726 return io.ErrUnexpectedEOF
2727 }
2728 m.Type = FlowDistinguisherMethodType(dAtA[iNdEx:postIndex])
2729 iNdEx = postIndex
2730 default:
2731 iNdEx = preIndex
2732 skippy, err := skipGenerated(dAtA[iNdEx:])
2733 if err != nil {
2734 return err
2735 }
2736 if (skippy < 0) || (iNdEx+skippy) < 0 {
2737 return ErrInvalidLengthGenerated
2738 }
2739 if (iNdEx + skippy) > l {
2740 return io.ErrUnexpectedEOF
2741 }
2742 iNdEx += skippy
2743 }
2744 }
2745
2746 if iNdEx > l {
2747 return io.ErrUnexpectedEOF
2748 }
2749 return nil
2750 }
2751 func (m *FlowSchema) Unmarshal(dAtA []byte) error {
2752 l := len(dAtA)
2753 iNdEx := 0
2754 for iNdEx < l {
2755 preIndex := iNdEx
2756 var wire uint64
2757 for shift := uint(0); ; shift += 7 {
2758 if shift >= 64 {
2759 return ErrIntOverflowGenerated
2760 }
2761 if iNdEx >= l {
2762 return io.ErrUnexpectedEOF
2763 }
2764 b := dAtA[iNdEx]
2765 iNdEx++
2766 wire |= uint64(b&0x7F) << shift
2767 if b < 0x80 {
2768 break
2769 }
2770 }
2771 fieldNum := int32(wire >> 3)
2772 wireType := int(wire & 0x7)
2773 if wireType == 4 {
2774 return fmt.Errorf("proto: FlowSchema: wiretype end group for non-group")
2775 }
2776 if fieldNum <= 0 {
2777 return fmt.Errorf("proto: FlowSchema: illegal tag %d (wire type %d)", fieldNum, wire)
2778 }
2779 switch fieldNum {
2780 case 1:
2781 if wireType != 2 {
2782 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2783 }
2784 var msglen int
2785 for shift := uint(0); ; shift += 7 {
2786 if shift >= 64 {
2787 return ErrIntOverflowGenerated
2788 }
2789 if iNdEx >= l {
2790 return io.ErrUnexpectedEOF
2791 }
2792 b := dAtA[iNdEx]
2793 iNdEx++
2794 msglen |= int(b&0x7F) << shift
2795 if b < 0x80 {
2796 break
2797 }
2798 }
2799 if msglen < 0 {
2800 return ErrInvalidLengthGenerated
2801 }
2802 postIndex := iNdEx + msglen
2803 if postIndex < 0 {
2804 return ErrInvalidLengthGenerated
2805 }
2806 if postIndex > l {
2807 return io.ErrUnexpectedEOF
2808 }
2809 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2810 return err
2811 }
2812 iNdEx = postIndex
2813 case 2:
2814 if wireType != 2 {
2815 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2816 }
2817 var msglen int
2818 for shift := uint(0); ; shift += 7 {
2819 if shift >= 64 {
2820 return ErrIntOverflowGenerated
2821 }
2822 if iNdEx >= l {
2823 return io.ErrUnexpectedEOF
2824 }
2825 b := dAtA[iNdEx]
2826 iNdEx++
2827 msglen |= int(b&0x7F) << shift
2828 if b < 0x80 {
2829 break
2830 }
2831 }
2832 if msglen < 0 {
2833 return ErrInvalidLengthGenerated
2834 }
2835 postIndex := iNdEx + msglen
2836 if postIndex < 0 {
2837 return ErrInvalidLengthGenerated
2838 }
2839 if postIndex > l {
2840 return io.ErrUnexpectedEOF
2841 }
2842 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2843 return err
2844 }
2845 iNdEx = postIndex
2846 case 3:
2847 if wireType != 2 {
2848 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2849 }
2850 var msglen int
2851 for shift := uint(0); ; shift += 7 {
2852 if shift >= 64 {
2853 return ErrIntOverflowGenerated
2854 }
2855 if iNdEx >= l {
2856 return io.ErrUnexpectedEOF
2857 }
2858 b := dAtA[iNdEx]
2859 iNdEx++
2860 msglen |= int(b&0x7F) << shift
2861 if b < 0x80 {
2862 break
2863 }
2864 }
2865 if msglen < 0 {
2866 return ErrInvalidLengthGenerated
2867 }
2868 postIndex := iNdEx + msglen
2869 if postIndex < 0 {
2870 return ErrInvalidLengthGenerated
2871 }
2872 if postIndex > l {
2873 return io.ErrUnexpectedEOF
2874 }
2875 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2876 return err
2877 }
2878 iNdEx = postIndex
2879 default:
2880 iNdEx = preIndex
2881 skippy, err := skipGenerated(dAtA[iNdEx:])
2882 if err != nil {
2883 return err
2884 }
2885 if (skippy < 0) || (iNdEx+skippy) < 0 {
2886 return ErrInvalidLengthGenerated
2887 }
2888 if (iNdEx + skippy) > l {
2889 return io.ErrUnexpectedEOF
2890 }
2891 iNdEx += skippy
2892 }
2893 }
2894
2895 if iNdEx > l {
2896 return io.ErrUnexpectedEOF
2897 }
2898 return nil
2899 }
2900 func (m *FlowSchemaCondition) Unmarshal(dAtA []byte) error {
2901 l := len(dAtA)
2902 iNdEx := 0
2903 for iNdEx < l {
2904 preIndex := iNdEx
2905 var wire uint64
2906 for shift := uint(0); ; shift += 7 {
2907 if shift >= 64 {
2908 return ErrIntOverflowGenerated
2909 }
2910 if iNdEx >= l {
2911 return io.ErrUnexpectedEOF
2912 }
2913 b := dAtA[iNdEx]
2914 iNdEx++
2915 wire |= uint64(b&0x7F) << shift
2916 if b < 0x80 {
2917 break
2918 }
2919 }
2920 fieldNum := int32(wire >> 3)
2921 wireType := int(wire & 0x7)
2922 if wireType == 4 {
2923 return fmt.Errorf("proto: FlowSchemaCondition: wiretype end group for non-group")
2924 }
2925 if fieldNum <= 0 {
2926 return fmt.Errorf("proto: FlowSchemaCondition: illegal tag %d (wire type %d)", fieldNum, wire)
2927 }
2928 switch fieldNum {
2929 case 1:
2930 if wireType != 2 {
2931 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2932 }
2933 var stringLen uint64
2934 for shift := uint(0); ; shift += 7 {
2935 if shift >= 64 {
2936 return ErrIntOverflowGenerated
2937 }
2938 if iNdEx >= l {
2939 return io.ErrUnexpectedEOF
2940 }
2941 b := dAtA[iNdEx]
2942 iNdEx++
2943 stringLen |= uint64(b&0x7F) << shift
2944 if b < 0x80 {
2945 break
2946 }
2947 }
2948 intStringLen := int(stringLen)
2949 if intStringLen < 0 {
2950 return ErrInvalidLengthGenerated
2951 }
2952 postIndex := iNdEx + intStringLen
2953 if postIndex < 0 {
2954 return ErrInvalidLengthGenerated
2955 }
2956 if postIndex > l {
2957 return io.ErrUnexpectedEOF
2958 }
2959 m.Type = FlowSchemaConditionType(dAtA[iNdEx:postIndex])
2960 iNdEx = postIndex
2961 case 2:
2962 if wireType != 2 {
2963 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2964 }
2965 var stringLen uint64
2966 for shift := uint(0); ; shift += 7 {
2967 if shift >= 64 {
2968 return ErrIntOverflowGenerated
2969 }
2970 if iNdEx >= l {
2971 return io.ErrUnexpectedEOF
2972 }
2973 b := dAtA[iNdEx]
2974 iNdEx++
2975 stringLen |= uint64(b&0x7F) << shift
2976 if b < 0x80 {
2977 break
2978 }
2979 }
2980 intStringLen := int(stringLen)
2981 if intStringLen < 0 {
2982 return ErrInvalidLengthGenerated
2983 }
2984 postIndex := iNdEx + intStringLen
2985 if postIndex < 0 {
2986 return ErrInvalidLengthGenerated
2987 }
2988 if postIndex > l {
2989 return io.ErrUnexpectedEOF
2990 }
2991 m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
2992 iNdEx = postIndex
2993 case 3:
2994 if wireType != 2 {
2995 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
2996 }
2997 var msglen int
2998 for shift := uint(0); ; shift += 7 {
2999 if shift >= 64 {
3000 return ErrIntOverflowGenerated
3001 }
3002 if iNdEx >= l {
3003 return io.ErrUnexpectedEOF
3004 }
3005 b := dAtA[iNdEx]
3006 iNdEx++
3007 msglen |= int(b&0x7F) << shift
3008 if b < 0x80 {
3009 break
3010 }
3011 }
3012 if msglen < 0 {
3013 return ErrInvalidLengthGenerated
3014 }
3015 postIndex := iNdEx + msglen
3016 if postIndex < 0 {
3017 return ErrInvalidLengthGenerated
3018 }
3019 if postIndex > l {
3020 return io.ErrUnexpectedEOF
3021 }
3022 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3023 return err
3024 }
3025 iNdEx = postIndex
3026 case 4:
3027 if wireType != 2 {
3028 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
3029 }
3030 var stringLen uint64
3031 for shift := uint(0); ; shift += 7 {
3032 if shift >= 64 {
3033 return ErrIntOverflowGenerated
3034 }
3035 if iNdEx >= l {
3036 return io.ErrUnexpectedEOF
3037 }
3038 b := dAtA[iNdEx]
3039 iNdEx++
3040 stringLen |= uint64(b&0x7F) << shift
3041 if b < 0x80 {
3042 break
3043 }
3044 }
3045 intStringLen := int(stringLen)
3046 if intStringLen < 0 {
3047 return ErrInvalidLengthGenerated
3048 }
3049 postIndex := iNdEx + intStringLen
3050 if postIndex < 0 {
3051 return ErrInvalidLengthGenerated
3052 }
3053 if postIndex > l {
3054 return io.ErrUnexpectedEOF
3055 }
3056 m.Reason = string(dAtA[iNdEx:postIndex])
3057 iNdEx = postIndex
3058 case 5:
3059 if wireType != 2 {
3060 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
3061 }
3062 var stringLen uint64
3063 for shift := uint(0); ; shift += 7 {
3064 if shift >= 64 {
3065 return ErrIntOverflowGenerated
3066 }
3067 if iNdEx >= l {
3068 return io.ErrUnexpectedEOF
3069 }
3070 b := dAtA[iNdEx]
3071 iNdEx++
3072 stringLen |= uint64(b&0x7F) << shift
3073 if b < 0x80 {
3074 break
3075 }
3076 }
3077 intStringLen := int(stringLen)
3078 if intStringLen < 0 {
3079 return ErrInvalidLengthGenerated
3080 }
3081 postIndex := iNdEx + intStringLen
3082 if postIndex < 0 {
3083 return ErrInvalidLengthGenerated
3084 }
3085 if postIndex > l {
3086 return io.ErrUnexpectedEOF
3087 }
3088 m.Message = string(dAtA[iNdEx:postIndex])
3089 iNdEx = postIndex
3090 default:
3091 iNdEx = preIndex
3092 skippy, err := skipGenerated(dAtA[iNdEx:])
3093 if err != nil {
3094 return err
3095 }
3096 if (skippy < 0) || (iNdEx+skippy) < 0 {
3097 return ErrInvalidLengthGenerated
3098 }
3099 if (iNdEx + skippy) > l {
3100 return io.ErrUnexpectedEOF
3101 }
3102 iNdEx += skippy
3103 }
3104 }
3105
3106 if iNdEx > l {
3107 return io.ErrUnexpectedEOF
3108 }
3109 return nil
3110 }
3111 func (m *FlowSchemaList) Unmarshal(dAtA []byte) error {
3112 l := len(dAtA)
3113 iNdEx := 0
3114 for iNdEx < l {
3115 preIndex := iNdEx
3116 var wire uint64
3117 for shift := uint(0); ; shift += 7 {
3118 if shift >= 64 {
3119 return ErrIntOverflowGenerated
3120 }
3121 if iNdEx >= l {
3122 return io.ErrUnexpectedEOF
3123 }
3124 b := dAtA[iNdEx]
3125 iNdEx++
3126 wire |= uint64(b&0x7F) << shift
3127 if b < 0x80 {
3128 break
3129 }
3130 }
3131 fieldNum := int32(wire >> 3)
3132 wireType := int(wire & 0x7)
3133 if wireType == 4 {
3134 return fmt.Errorf("proto: FlowSchemaList: wiretype end group for non-group")
3135 }
3136 if fieldNum <= 0 {
3137 return fmt.Errorf("proto: FlowSchemaList: illegal tag %d (wire type %d)", fieldNum, wire)
3138 }
3139 switch fieldNum {
3140 case 1:
3141 if wireType != 2 {
3142 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3143 }
3144 var msglen int
3145 for shift := uint(0); ; shift += 7 {
3146 if shift >= 64 {
3147 return ErrIntOverflowGenerated
3148 }
3149 if iNdEx >= l {
3150 return io.ErrUnexpectedEOF
3151 }
3152 b := dAtA[iNdEx]
3153 iNdEx++
3154 msglen |= int(b&0x7F) << shift
3155 if b < 0x80 {
3156 break
3157 }
3158 }
3159 if msglen < 0 {
3160 return ErrInvalidLengthGenerated
3161 }
3162 postIndex := iNdEx + msglen
3163 if postIndex < 0 {
3164 return ErrInvalidLengthGenerated
3165 }
3166 if postIndex > l {
3167 return io.ErrUnexpectedEOF
3168 }
3169 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3170 return err
3171 }
3172 iNdEx = postIndex
3173 case 2:
3174 if wireType != 2 {
3175 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3176 }
3177 var msglen int
3178 for shift := uint(0); ; shift += 7 {
3179 if shift >= 64 {
3180 return ErrIntOverflowGenerated
3181 }
3182 if iNdEx >= l {
3183 return io.ErrUnexpectedEOF
3184 }
3185 b := dAtA[iNdEx]
3186 iNdEx++
3187 msglen |= int(b&0x7F) << shift
3188 if b < 0x80 {
3189 break
3190 }
3191 }
3192 if msglen < 0 {
3193 return ErrInvalidLengthGenerated
3194 }
3195 postIndex := iNdEx + msglen
3196 if postIndex < 0 {
3197 return ErrInvalidLengthGenerated
3198 }
3199 if postIndex > l {
3200 return io.ErrUnexpectedEOF
3201 }
3202 m.Items = append(m.Items, FlowSchema{})
3203 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3204 return err
3205 }
3206 iNdEx = postIndex
3207 default:
3208 iNdEx = preIndex
3209 skippy, err := skipGenerated(dAtA[iNdEx:])
3210 if err != nil {
3211 return err
3212 }
3213 if (skippy < 0) || (iNdEx+skippy) < 0 {
3214 return ErrInvalidLengthGenerated
3215 }
3216 if (iNdEx + skippy) > l {
3217 return io.ErrUnexpectedEOF
3218 }
3219 iNdEx += skippy
3220 }
3221 }
3222
3223 if iNdEx > l {
3224 return io.ErrUnexpectedEOF
3225 }
3226 return nil
3227 }
3228 func (m *FlowSchemaSpec) Unmarshal(dAtA []byte) error {
3229 l := len(dAtA)
3230 iNdEx := 0
3231 for iNdEx < l {
3232 preIndex := iNdEx
3233 var wire uint64
3234 for shift := uint(0); ; shift += 7 {
3235 if shift >= 64 {
3236 return ErrIntOverflowGenerated
3237 }
3238 if iNdEx >= l {
3239 return io.ErrUnexpectedEOF
3240 }
3241 b := dAtA[iNdEx]
3242 iNdEx++
3243 wire |= uint64(b&0x7F) << shift
3244 if b < 0x80 {
3245 break
3246 }
3247 }
3248 fieldNum := int32(wire >> 3)
3249 wireType := int(wire & 0x7)
3250 if wireType == 4 {
3251 return fmt.Errorf("proto: FlowSchemaSpec: wiretype end group for non-group")
3252 }
3253 if fieldNum <= 0 {
3254 return fmt.Errorf("proto: FlowSchemaSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3255 }
3256 switch fieldNum {
3257 case 1:
3258 if wireType != 2 {
3259 return fmt.Errorf("proto: wrong wireType = %d for field PriorityLevelConfiguration", wireType)
3260 }
3261 var msglen int
3262 for shift := uint(0); ; shift += 7 {
3263 if shift >= 64 {
3264 return ErrIntOverflowGenerated
3265 }
3266 if iNdEx >= l {
3267 return io.ErrUnexpectedEOF
3268 }
3269 b := dAtA[iNdEx]
3270 iNdEx++
3271 msglen |= int(b&0x7F) << shift
3272 if b < 0x80 {
3273 break
3274 }
3275 }
3276 if msglen < 0 {
3277 return ErrInvalidLengthGenerated
3278 }
3279 postIndex := iNdEx + msglen
3280 if postIndex < 0 {
3281 return ErrInvalidLengthGenerated
3282 }
3283 if postIndex > l {
3284 return io.ErrUnexpectedEOF
3285 }
3286 if err := m.PriorityLevelConfiguration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3287 return err
3288 }
3289 iNdEx = postIndex
3290 case 2:
3291 if wireType != 0 {
3292 return fmt.Errorf("proto: wrong wireType = %d for field MatchingPrecedence", wireType)
3293 }
3294 m.MatchingPrecedence = 0
3295 for shift := uint(0); ; shift += 7 {
3296 if shift >= 64 {
3297 return ErrIntOverflowGenerated
3298 }
3299 if iNdEx >= l {
3300 return io.ErrUnexpectedEOF
3301 }
3302 b := dAtA[iNdEx]
3303 iNdEx++
3304 m.MatchingPrecedence |= int32(b&0x7F) << shift
3305 if b < 0x80 {
3306 break
3307 }
3308 }
3309 case 3:
3310 if wireType != 2 {
3311 return fmt.Errorf("proto: wrong wireType = %d for field DistinguisherMethod", wireType)
3312 }
3313 var msglen int
3314 for shift := uint(0); ; shift += 7 {
3315 if shift >= 64 {
3316 return ErrIntOverflowGenerated
3317 }
3318 if iNdEx >= l {
3319 return io.ErrUnexpectedEOF
3320 }
3321 b := dAtA[iNdEx]
3322 iNdEx++
3323 msglen |= int(b&0x7F) << shift
3324 if b < 0x80 {
3325 break
3326 }
3327 }
3328 if msglen < 0 {
3329 return ErrInvalidLengthGenerated
3330 }
3331 postIndex := iNdEx + msglen
3332 if postIndex < 0 {
3333 return ErrInvalidLengthGenerated
3334 }
3335 if postIndex > l {
3336 return io.ErrUnexpectedEOF
3337 }
3338 if m.DistinguisherMethod == nil {
3339 m.DistinguisherMethod = &FlowDistinguisherMethod{}
3340 }
3341 if err := m.DistinguisherMethod.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3342 return err
3343 }
3344 iNdEx = postIndex
3345 case 4:
3346 if wireType != 2 {
3347 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
3348 }
3349 var msglen int
3350 for shift := uint(0); ; shift += 7 {
3351 if shift >= 64 {
3352 return ErrIntOverflowGenerated
3353 }
3354 if iNdEx >= l {
3355 return io.ErrUnexpectedEOF
3356 }
3357 b := dAtA[iNdEx]
3358 iNdEx++
3359 msglen |= int(b&0x7F) << shift
3360 if b < 0x80 {
3361 break
3362 }
3363 }
3364 if msglen < 0 {
3365 return ErrInvalidLengthGenerated
3366 }
3367 postIndex := iNdEx + msglen
3368 if postIndex < 0 {
3369 return ErrInvalidLengthGenerated
3370 }
3371 if postIndex > l {
3372 return io.ErrUnexpectedEOF
3373 }
3374 m.Rules = append(m.Rules, PolicyRulesWithSubjects{})
3375 if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3376 return err
3377 }
3378 iNdEx = postIndex
3379 default:
3380 iNdEx = preIndex
3381 skippy, err := skipGenerated(dAtA[iNdEx:])
3382 if err != nil {
3383 return err
3384 }
3385 if (skippy < 0) || (iNdEx+skippy) < 0 {
3386 return ErrInvalidLengthGenerated
3387 }
3388 if (iNdEx + skippy) > l {
3389 return io.ErrUnexpectedEOF
3390 }
3391 iNdEx += skippy
3392 }
3393 }
3394
3395 if iNdEx > l {
3396 return io.ErrUnexpectedEOF
3397 }
3398 return nil
3399 }
3400 func (m *FlowSchemaStatus) Unmarshal(dAtA []byte) error {
3401 l := len(dAtA)
3402 iNdEx := 0
3403 for iNdEx < l {
3404 preIndex := iNdEx
3405 var wire uint64
3406 for shift := uint(0); ; shift += 7 {
3407 if shift >= 64 {
3408 return ErrIntOverflowGenerated
3409 }
3410 if iNdEx >= l {
3411 return io.ErrUnexpectedEOF
3412 }
3413 b := dAtA[iNdEx]
3414 iNdEx++
3415 wire |= uint64(b&0x7F) << shift
3416 if b < 0x80 {
3417 break
3418 }
3419 }
3420 fieldNum := int32(wire >> 3)
3421 wireType := int(wire & 0x7)
3422 if wireType == 4 {
3423 return fmt.Errorf("proto: FlowSchemaStatus: wiretype end group for non-group")
3424 }
3425 if fieldNum <= 0 {
3426 return fmt.Errorf("proto: FlowSchemaStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3427 }
3428 switch fieldNum {
3429 case 1:
3430 if wireType != 2 {
3431 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
3432 }
3433 var msglen int
3434 for shift := uint(0); ; shift += 7 {
3435 if shift >= 64 {
3436 return ErrIntOverflowGenerated
3437 }
3438 if iNdEx >= l {
3439 return io.ErrUnexpectedEOF
3440 }
3441 b := dAtA[iNdEx]
3442 iNdEx++
3443 msglen |= int(b&0x7F) << shift
3444 if b < 0x80 {
3445 break
3446 }
3447 }
3448 if msglen < 0 {
3449 return ErrInvalidLengthGenerated
3450 }
3451 postIndex := iNdEx + msglen
3452 if postIndex < 0 {
3453 return ErrInvalidLengthGenerated
3454 }
3455 if postIndex > l {
3456 return io.ErrUnexpectedEOF
3457 }
3458 m.Conditions = append(m.Conditions, FlowSchemaCondition{})
3459 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3460 return err
3461 }
3462 iNdEx = postIndex
3463 default:
3464 iNdEx = preIndex
3465 skippy, err := skipGenerated(dAtA[iNdEx:])
3466 if err != nil {
3467 return err
3468 }
3469 if (skippy < 0) || (iNdEx+skippy) < 0 {
3470 return ErrInvalidLengthGenerated
3471 }
3472 if (iNdEx + skippy) > l {
3473 return io.ErrUnexpectedEOF
3474 }
3475 iNdEx += skippy
3476 }
3477 }
3478
3479 if iNdEx > l {
3480 return io.ErrUnexpectedEOF
3481 }
3482 return nil
3483 }
3484 func (m *GroupSubject) Unmarshal(dAtA []byte) error {
3485 l := len(dAtA)
3486 iNdEx := 0
3487 for iNdEx < l {
3488 preIndex := iNdEx
3489 var wire uint64
3490 for shift := uint(0); ; shift += 7 {
3491 if shift >= 64 {
3492 return ErrIntOverflowGenerated
3493 }
3494 if iNdEx >= l {
3495 return io.ErrUnexpectedEOF
3496 }
3497 b := dAtA[iNdEx]
3498 iNdEx++
3499 wire |= uint64(b&0x7F) << shift
3500 if b < 0x80 {
3501 break
3502 }
3503 }
3504 fieldNum := int32(wire >> 3)
3505 wireType := int(wire & 0x7)
3506 if wireType == 4 {
3507 return fmt.Errorf("proto: GroupSubject: wiretype end group for non-group")
3508 }
3509 if fieldNum <= 0 {
3510 return fmt.Errorf("proto: GroupSubject: illegal tag %d (wire type %d)", fieldNum, wire)
3511 }
3512 switch fieldNum {
3513 case 1:
3514 if wireType != 2 {
3515 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
3516 }
3517 var stringLen uint64
3518 for shift := uint(0); ; shift += 7 {
3519 if shift >= 64 {
3520 return ErrIntOverflowGenerated
3521 }
3522 if iNdEx >= l {
3523 return io.ErrUnexpectedEOF
3524 }
3525 b := dAtA[iNdEx]
3526 iNdEx++
3527 stringLen |= uint64(b&0x7F) << shift
3528 if b < 0x80 {
3529 break
3530 }
3531 }
3532 intStringLen := int(stringLen)
3533 if intStringLen < 0 {
3534 return ErrInvalidLengthGenerated
3535 }
3536 postIndex := iNdEx + intStringLen
3537 if postIndex < 0 {
3538 return ErrInvalidLengthGenerated
3539 }
3540 if postIndex > l {
3541 return io.ErrUnexpectedEOF
3542 }
3543 m.Name = string(dAtA[iNdEx:postIndex])
3544 iNdEx = postIndex
3545 default:
3546 iNdEx = preIndex
3547 skippy, err := skipGenerated(dAtA[iNdEx:])
3548 if err != nil {
3549 return err
3550 }
3551 if (skippy < 0) || (iNdEx+skippy) < 0 {
3552 return ErrInvalidLengthGenerated
3553 }
3554 if (iNdEx + skippy) > l {
3555 return io.ErrUnexpectedEOF
3556 }
3557 iNdEx += skippy
3558 }
3559 }
3560
3561 if iNdEx > l {
3562 return io.ErrUnexpectedEOF
3563 }
3564 return nil
3565 }
3566 func (m *LimitResponse) Unmarshal(dAtA []byte) error {
3567 l := len(dAtA)
3568 iNdEx := 0
3569 for iNdEx < l {
3570 preIndex := iNdEx
3571 var wire uint64
3572 for shift := uint(0); ; shift += 7 {
3573 if shift >= 64 {
3574 return ErrIntOverflowGenerated
3575 }
3576 if iNdEx >= l {
3577 return io.ErrUnexpectedEOF
3578 }
3579 b := dAtA[iNdEx]
3580 iNdEx++
3581 wire |= uint64(b&0x7F) << shift
3582 if b < 0x80 {
3583 break
3584 }
3585 }
3586 fieldNum := int32(wire >> 3)
3587 wireType := int(wire & 0x7)
3588 if wireType == 4 {
3589 return fmt.Errorf("proto: LimitResponse: wiretype end group for non-group")
3590 }
3591 if fieldNum <= 0 {
3592 return fmt.Errorf("proto: LimitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3593 }
3594 switch fieldNum {
3595 case 1:
3596 if wireType != 2 {
3597 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3598 }
3599 var stringLen uint64
3600 for shift := uint(0); ; shift += 7 {
3601 if shift >= 64 {
3602 return ErrIntOverflowGenerated
3603 }
3604 if iNdEx >= l {
3605 return io.ErrUnexpectedEOF
3606 }
3607 b := dAtA[iNdEx]
3608 iNdEx++
3609 stringLen |= uint64(b&0x7F) << shift
3610 if b < 0x80 {
3611 break
3612 }
3613 }
3614 intStringLen := int(stringLen)
3615 if intStringLen < 0 {
3616 return ErrInvalidLengthGenerated
3617 }
3618 postIndex := iNdEx + intStringLen
3619 if postIndex < 0 {
3620 return ErrInvalidLengthGenerated
3621 }
3622 if postIndex > l {
3623 return io.ErrUnexpectedEOF
3624 }
3625 m.Type = LimitResponseType(dAtA[iNdEx:postIndex])
3626 iNdEx = postIndex
3627 case 2:
3628 if wireType != 2 {
3629 return fmt.Errorf("proto: wrong wireType = %d for field Queuing", wireType)
3630 }
3631 var msglen int
3632 for shift := uint(0); ; shift += 7 {
3633 if shift >= 64 {
3634 return ErrIntOverflowGenerated
3635 }
3636 if iNdEx >= l {
3637 return io.ErrUnexpectedEOF
3638 }
3639 b := dAtA[iNdEx]
3640 iNdEx++
3641 msglen |= int(b&0x7F) << shift
3642 if b < 0x80 {
3643 break
3644 }
3645 }
3646 if msglen < 0 {
3647 return ErrInvalidLengthGenerated
3648 }
3649 postIndex := iNdEx + msglen
3650 if postIndex < 0 {
3651 return ErrInvalidLengthGenerated
3652 }
3653 if postIndex > l {
3654 return io.ErrUnexpectedEOF
3655 }
3656 if m.Queuing == nil {
3657 m.Queuing = &QueuingConfiguration{}
3658 }
3659 if err := m.Queuing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3660 return err
3661 }
3662 iNdEx = postIndex
3663 default:
3664 iNdEx = preIndex
3665 skippy, err := skipGenerated(dAtA[iNdEx:])
3666 if err != nil {
3667 return err
3668 }
3669 if (skippy < 0) || (iNdEx+skippy) < 0 {
3670 return ErrInvalidLengthGenerated
3671 }
3672 if (iNdEx + skippy) > l {
3673 return io.ErrUnexpectedEOF
3674 }
3675 iNdEx += skippy
3676 }
3677 }
3678
3679 if iNdEx > l {
3680 return io.ErrUnexpectedEOF
3681 }
3682 return nil
3683 }
3684 func (m *LimitedPriorityLevelConfiguration) Unmarshal(dAtA []byte) error {
3685 l := len(dAtA)
3686 iNdEx := 0
3687 for iNdEx < l {
3688 preIndex := iNdEx
3689 var wire uint64
3690 for shift := uint(0); ; shift += 7 {
3691 if shift >= 64 {
3692 return ErrIntOverflowGenerated
3693 }
3694 if iNdEx >= l {
3695 return io.ErrUnexpectedEOF
3696 }
3697 b := dAtA[iNdEx]
3698 iNdEx++
3699 wire |= uint64(b&0x7F) << shift
3700 if b < 0x80 {
3701 break
3702 }
3703 }
3704 fieldNum := int32(wire >> 3)
3705 wireType := int(wire & 0x7)
3706 if wireType == 4 {
3707 return fmt.Errorf("proto: LimitedPriorityLevelConfiguration: wiretype end group for non-group")
3708 }
3709 if fieldNum <= 0 {
3710 return fmt.Errorf("proto: LimitedPriorityLevelConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
3711 }
3712 switch fieldNum {
3713 case 1:
3714 if wireType != 0 {
3715 return fmt.Errorf("proto: wrong wireType = %d for field AssuredConcurrencyShares", wireType)
3716 }
3717 m.AssuredConcurrencyShares = 0
3718 for shift := uint(0); ; shift += 7 {
3719 if shift >= 64 {
3720 return ErrIntOverflowGenerated
3721 }
3722 if iNdEx >= l {
3723 return io.ErrUnexpectedEOF
3724 }
3725 b := dAtA[iNdEx]
3726 iNdEx++
3727 m.AssuredConcurrencyShares |= int32(b&0x7F) << shift
3728 if b < 0x80 {
3729 break
3730 }
3731 }
3732 case 2:
3733 if wireType != 2 {
3734 return fmt.Errorf("proto: wrong wireType = %d for field LimitResponse", wireType)
3735 }
3736 var msglen int
3737 for shift := uint(0); ; shift += 7 {
3738 if shift >= 64 {
3739 return ErrIntOverflowGenerated
3740 }
3741 if iNdEx >= l {
3742 return io.ErrUnexpectedEOF
3743 }
3744 b := dAtA[iNdEx]
3745 iNdEx++
3746 msglen |= int(b&0x7F) << shift
3747 if b < 0x80 {
3748 break
3749 }
3750 }
3751 if msglen < 0 {
3752 return ErrInvalidLengthGenerated
3753 }
3754 postIndex := iNdEx + msglen
3755 if postIndex < 0 {
3756 return ErrInvalidLengthGenerated
3757 }
3758 if postIndex > l {
3759 return io.ErrUnexpectedEOF
3760 }
3761 if err := m.LimitResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3762 return err
3763 }
3764 iNdEx = postIndex
3765 case 3:
3766 if wireType != 0 {
3767 return fmt.Errorf("proto: wrong wireType = %d for field LendablePercent", wireType)
3768 }
3769 var v int32
3770 for shift := uint(0); ; shift += 7 {
3771 if shift >= 64 {
3772 return ErrIntOverflowGenerated
3773 }
3774 if iNdEx >= l {
3775 return io.ErrUnexpectedEOF
3776 }
3777 b := dAtA[iNdEx]
3778 iNdEx++
3779 v |= int32(b&0x7F) << shift
3780 if b < 0x80 {
3781 break
3782 }
3783 }
3784 m.LendablePercent = &v
3785 case 4:
3786 if wireType != 0 {
3787 return fmt.Errorf("proto: wrong wireType = %d for field BorrowingLimitPercent", wireType)
3788 }
3789 var v int32
3790 for shift := uint(0); ; shift += 7 {
3791 if shift >= 64 {
3792 return ErrIntOverflowGenerated
3793 }
3794 if iNdEx >= l {
3795 return io.ErrUnexpectedEOF
3796 }
3797 b := dAtA[iNdEx]
3798 iNdEx++
3799 v |= int32(b&0x7F) << shift
3800 if b < 0x80 {
3801 break
3802 }
3803 }
3804 m.BorrowingLimitPercent = &v
3805 default:
3806 iNdEx = preIndex
3807 skippy, err := skipGenerated(dAtA[iNdEx:])
3808 if err != nil {
3809 return err
3810 }
3811 if (skippy < 0) || (iNdEx+skippy) < 0 {
3812 return ErrInvalidLengthGenerated
3813 }
3814 if (iNdEx + skippy) > l {
3815 return io.ErrUnexpectedEOF
3816 }
3817 iNdEx += skippy
3818 }
3819 }
3820
3821 if iNdEx > l {
3822 return io.ErrUnexpectedEOF
3823 }
3824 return nil
3825 }
3826 func (m *NonResourcePolicyRule) Unmarshal(dAtA []byte) error {
3827 l := len(dAtA)
3828 iNdEx := 0
3829 for iNdEx < l {
3830 preIndex := iNdEx
3831 var wire uint64
3832 for shift := uint(0); ; shift += 7 {
3833 if shift >= 64 {
3834 return ErrIntOverflowGenerated
3835 }
3836 if iNdEx >= l {
3837 return io.ErrUnexpectedEOF
3838 }
3839 b := dAtA[iNdEx]
3840 iNdEx++
3841 wire |= uint64(b&0x7F) << shift
3842 if b < 0x80 {
3843 break
3844 }
3845 }
3846 fieldNum := int32(wire >> 3)
3847 wireType := int(wire & 0x7)
3848 if wireType == 4 {
3849 return fmt.Errorf("proto: NonResourcePolicyRule: wiretype end group for non-group")
3850 }
3851 if fieldNum <= 0 {
3852 return fmt.Errorf("proto: NonResourcePolicyRule: illegal tag %d (wire type %d)", fieldNum, wire)
3853 }
3854 switch fieldNum {
3855 case 1:
3856 if wireType != 2 {
3857 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
3858 }
3859 var stringLen uint64
3860 for shift := uint(0); ; shift += 7 {
3861 if shift >= 64 {
3862 return ErrIntOverflowGenerated
3863 }
3864 if iNdEx >= l {
3865 return io.ErrUnexpectedEOF
3866 }
3867 b := dAtA[iNdEx]
3868 iNdEx++
3869 stringLen |= uint64(b&0x7F) << shift
3870 if b < 0x80 {
3871 break
3872 }
3873 }
3874 intStringLen := int(stringLen)
3875 if intStringLen < 0 {
3876 return ErrInvalidLengthGenerated
3877 }
3878 postIndex := iNdEx + intStringLen
3879 if postIndex < 0 {
3880 return ErrInvalidLengthGenerated
3881 }
3882 if postIndex > l {
3883 return io.ErrUnexpectedEOF
3884 }
3885 m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex]))
3886 iNdEx = postIndex
3887 case 6:
3888 if wireType != 2 {
3889 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceURLs", wireType)
3890 }
3891 var stringLen uint64
3892 for shift := uint(0); ; shift += 7 {
3893 if shift >= 64 {
3894 return ErrIntOverflowGenerated
3895 }
3896 if iNdEx >= l {
3897 return io.ErrUnexpectedEOF
3898 }
3899 b := dAtA[iNdEx]
3900 iNdEx++
3901 stringLen |= uint64(b&0x7F) << shift
3902 if b < 0x80 {
3903 break
3904 }
3905 }
3906 intStringLen := int(stringLen)
3907 if intStringLen < 0 {
3908 return ErrInvalidLengthGenerated
3909 }
3910 postIndex := iNdEx + intStringLen
3911 if postIndex < 0 {
3912 return ErrInvalidLengthGenerated
3913 }
3914 if postIndex > l {
3915 return io.ErrUnexpectedEOF
3916 }
3917 m.NonResourceURLs = append(m.NonResourceURLs, string(dAtA[iNdEx:postIndex]))
3918 iNdEx = postIndex
3919 default:
3920 iNdEx = preIndex
3921 skippy, err := skipGenerated(dAtA[iNdEx:])
3922 if err != nil {
3923 return err
3924 }
3925 if (skippy < 0) || (iNdEx+skippy) < 0 {
3926 return ErrInvalidLengthGenerated
3927 }
3928 if (iNdEx + skippy) > l {
3929 return io.ErrUnexpectedEOF
3930 }
3931 iNdEx += skippy
3932 }
3933 }
3934
3935 if iNdEx > l {
3936 return io.ErrUnexpectedEOF
3937 }
3938 return nil
3939 }
3940 func (m *PolicyRulesWithSubjects) Unmarshal(dAtA []byte) error {
3941 l := len(dAtA)
3942 iNdEx := 0
3943 for iNdEx < l {
3944 preIndex := iNdEx
3945 var wire uint64
3946 for shift := uint(0); ; shift += 7 {
3947 if shift >= 64 {
3948 return ErrIntOverflowGenerated
3949 }
3950 if iNdEx >= l {
3951 return io.ErrUnexpectedEOF
3952 }
3953 b := dAtA[iNdEx]
3954 iNdEx++
3955 wire |= uint64(b&0x7F) << shift
3956 if b < 0x80 {
3957 break
3958 }
3959 }
3960 fieldNum := int32(wire >> 3)
3961 wireType := int(wire & 0x7)
3962 if wireType == 4 {
3963 return fmt.Errorf("proto: PolicyRulesWithSubjects: wiretype end group for non-group")
3964 }
3965 if fieldNum <= 0 {
3966 return fmt.Errorf("proto: PolicyRulesWithSubjects: illegal tag %d (wire type %d)", fieldNum, wire)
3967 }
3968 switch fieldNum {
3969 case 1:
3970 if wireType != 2 {
3971 return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
3972 }
3973 var msglen int
3974 for shift := uint(0); ; shift += 7 {
3975 if shift >= 64 {
3976 return ErrIntOverflowGenerated
3977 }
3978 if iNdEx >= l {
3979 return io.ErrUnexpectedEOF
3980 }
3981 b := dAtA[iNdEx]
3982 iNdEx++
3983 msglen |= int(b&0x7F) << shift
3984 if b < 0x80 {
3985 break
3986 }
3987 }
3988 if msglen < 0 {
3989 return ErrInvalidLengthGenerated
3990 }
3991 postIndex := iNdEx + msglen
3992 if postIndex < 0 {
3993 return ErrInvalidLengthGenerated
3994 }
3995 if postIndex > l {
3996 return io.ErrUnexpectedEOF
3997 }
3998 m.Subjects = append(m.Subjects, Subject{})
3999 if err := m.Subjects[len(m.Subjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4000 return err
4001 }
4002 iNdEx = postIndex
4003 case 2:
4004 if wireType != 2 {
4005 return fmt.Errorf("proto: wrong wireType = %d for field ResourceRules", wireType)
4006 }
4007 var msglen int
4008 for shift := uint(0); ; shift += 7 {
4009 if shift >= 64 {
4010 return ErrIntOverflowGenerated
4011 }
4012 if iNdEx >= l {
4013 return io.ErrUnexpectedEOF
4014 }
4015 b := dAtA[iNdEx]
4016 iNdEx++
4017 msglen |= int(b&0x7F) << shift
4018 if b < 0x80 {
4019 break
4020 }
4021 }
4022 if msglen < 0 {
4023 return ErrInvalidLengthGenerated
4024 }
4025 postIndex := iNdEx + msglen
4026 if postIndex < 0 {
4027 return ErrInvalidLengthGenerated
4028 }
4029 if postIndex > l {
4030 return io.ErrUnexpectedEOF
4031 }
4032 m.ResourceRules = append(m.ResourceRules, ResourcePolicyRule{})
4033 if err := m.ResourceRules[len(m.ResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4034 return err
4035 }
4036 iNdEx = postIndex
4037 case 3:
4038 if wireType != 2 {
4039 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceRules", wireType)
4040 }
4041 var msglen int
4042 for shift := uint(0); ; shift += 7 {
4043 if shift >= 64 {
4044 return ErrIntOverflowGenerated
4045 }
4046 if iNdEx >= l {
4047 return io.ErrUnexpectedEOF
4048 }
4049 b := dAtA[iNdEx]
4050 iNdEx++
4051 msglen |= int(b&0x7F) << shift
4052 if b < 0x80 {
4053 break
4054 }
4055 }
4056 if msglen < 0 {
4057 return ErrInvalidLengthGenerated
4058 }
4059 postIndex := iNdEx + msglen
4060 if postIndex < 0 {
4061 return ErrInvalidLengthGenerated
4062 }
4063 if postIndex > l {
4064 return io.ErrUnexpectedEOF
4065 }
4066 m.NonResourceRules = append(m.NonResourceRules, NonResourcePolicyRule{})
4067 if err := m.NonResourceRules[len(m.NonResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4068 return err
4069 }
4070 iNdEx = postIndex
4071 default:
4072 iNdEx = preIndex
4073 skippy, err := skipGenerated(dAtA[iNdEx:])
4074 if err != nil {
4075 return err
4076 }
4077 if (skippy < 0) || (iNdEx+skippy) < 0 {
4078 return ErrInvalidLengthGenerated
4079 }
4080 if (iNdEx + skippy) > l {
4081 return io.ErrUnexpectedEOF
4082 }
4083 iNdEx += skippy
4084 }
4085 }
4086
4087 if iNdEx > l {
4088 return io.ErrUnexpectedEOF
4089 }
4090 return nil
4091 }
4092 func (m *PriorityLevelConfiguration) Unmarshal(dAtA []byte) error {
4093 l := len(dAtA)
4094 iNdEx := 0
4095 for iNdEx < l {
4096 preIndex := iNdEx
4097 var wire uint64
4098 for shift := uint(0); ; shift += 7 {
4099 if shift >= 64 {
4100 return ErrIntOverflowGenerated
4101 }
4102 if iNdEx >= l {
4103 return io.ErrUnexpectedEOF
4104 }
4105 b := dAtA[iNdEx]
4106 iNdEx++
4107 wire |= uint64(b&0x7F) << shift
4108 if b < 0x80 {
4109 break
4110 }
4111 }
4112 fieldNum := int32(wire >> 3)
4113 wireType := int(wire & 0x7)
4114 if wireType == 4 {
4115 return fmt.Errorf("proto: PriorityLevelConfiguration: wiretype end group for non-group")
4116 }
4117 if fieldNum <= 0 {
4118 return fmt.Errorf("proto: PriorityLevelConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
4119 }
4120 switch fieldNum {
4121 case 1:
4122 if wireType != 2 {
4123 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4124 }
4125 var msglen int
4126 for shift := uint(0); ; shift += 7 {
4127 if shift >= 64 {
4128 return ErrIntOverflowGenerated
4129 }
4130 if iNdEx >= l {
4131 return io.ErrUnexpectedEOF
4132 }
4133 b := dAtA[iNdEx]
4134 iNdEx++
4135 msglen |= int(b&0x7F) << shift
4136 if b < 0x80 {
4137 break
4138 }
4139 }
4140 if msglen < 0 {
4141 return ErrInvalidLengthGenerated
4142 }
4143 postIndex := iNdEx + msglen
4144 if postIndex < 0 {
4145 return ErrInvalidLengthGenerated
4146 }
4147 if postIndex > l {
4148 return io.ErrUnexpectedEOF
4149 }
4150 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4151 return err
4152 }
4153 iNdEx = postIndex
4154 case 2:
4155 if wireType != 2 {
4156 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4157 }
4158 var msglen int
4159 for shift := uint(0); ; shift += 7 {
4160 if shift >= 64 {
4161 return ErrIntOverflowGenerated
4162 }
4163 if iNdEx >= l {
4164 return io.ErrUnexpectedEOF
4165 }
4166 b := dAtA[iNdEx]
4167 iNdEx++
4168 msglen |= int(b&0x7F) << shift
4169 if b < 0x80 {
4170 break
4171 }
4172 }
4173 if msglen < 0 {
4174 return ErrInvalidLengthGenerated
4175 }
4176 postIndex := iNdEx + msglen
4177 if postIndex < 0 {
4178 return ErrInvalidLengthGenerated
4179 }
4180 if postIndex > l {
4181 return io.ErrUnexpectedEOF
4182 }
4183 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4184 return err
4185 }
4186 iNdEx = postIndex
4187 case 3:
4188 if wireType != 2 {
4189 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4190 }
4191 var msglen int
4192 for shift := uint(0); ; shift += 7 {
4193 if shift >= 64 {
4194 return ErrIntOverflowGenerated
4195 }
4196 if iNdEx >= l {
4197 return io.ErrUnexpectedEOF
4198 }
4199 b := dAtA[iNdEx]
4200 iNdEx++
4201 msglen |= int(b&0x7F) << shift
4202 if b < 0x80 {
4203 break
4204 }
4205 }
4206 if msglen < 0 {
4207 return ErrInvalidLengthGenerated
4208 }
4209 postIndex := iNdEx + msglen
4210 if postIndex < 0 {
4211 return ErrInvalidLengthGenerated
4212 }
4213 if postIndex > l {
4214 return io.ErrUnexpectedEOF
4215 }
4216 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4217 return err
4218 }
4219 iNdEx = postIndex
4220 default:
4221 iNdEx = preIndex
4222 skippy, err := skipGenerated(dAtA[iNdEx:])
4223 if err != nil {
4224 return err
4225 }
4226 if (skippy < 0) || (iNdEx+skippy) < 0 {
4227 return ErrInvalidLengthGenerated
4228 }
4229 if (iNdEx + skippy) > l {
4230 return io.ErrUnexpectedEOF
4231 }
4232 iNdEx += skippy
4233 }
4234 }
4235
4236 if iNdEx > l {
4237 return io.ErrUnexpectedEOF
4238 }
4239 return nil
4240 }
4241 func (m *PriorityLevelConfigurationCondition) Unmarshal(dAtA []byte) error {
4242 l := len(dAtA)
4243 iNdEx := 0
4244 for iNdEx < l {
4245 preIndex := iNdEx
4246 var wire uint64
4247 for shift := uint(0); ; shift += 7 {
4248 if shift >= 64 {
4249 return ErrIntOverflowGenerated
4250 }
4251 if iNdEx >= l {
4252 return io.ErrUnexpectedEOF
4253 }
4254 b := dAtA[iNdEx]
4255 iNdEx++
4256 wire |= uint64(b&0x7F) << shift
4257 if b < 0x80 {
4258 break
4259 }
4260 }
4261 fieldNum := int32(wire >> 3)
4262 wireType := int(wire & 0x7)
4263 if wireType == 4 {
4264 return fmt.Errorf("proto: PriorityLevelConfigurationCondition: wiretype end group for non-group")
4265 }
4266 if fieldNum <= 0 {
4267 return fmt.Errorf("proto: PriorityLevelConfigurationCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4268 }
4269 switch fieldNum {
4270 case 1:
4271 if wireType != 2 {
4272 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4273 }
4274 var stringLen uint64
4275 for shift := uint(0); ; shift += 7 {
4276 if shift >= 64 {
4277 return ErrIntOverflowGenerated
4278 }
4279 if iNdEx >= l {
4280 return io.ErrUnexpectedEOF
4281 }
4282 b := dAtA[iNdEx]
4283 iNdEx++
4284 stringLen |= uint64(b&0x7F) << shift
4285 if b < 0x80 {
4286 break
4287 }
4288 }
4289 intStringLen := int(stringLen)
4290 if intStringLen < 0 {
4291 return ErrInvalidLengthGenerated
4292 }
4293 postIndex := iNdEx + intStringLen
4294 if postIndex < 0 {
4295 return ErrInvalidLengthGenerated
4296 }
4297 if postIndex > l {
4298 return io.ErrUnexpectedEOF
4299 }
4300 m.Type = PriorityLevelConfigurationConditionType(dAtA[iNdEx:postIndex])
4301 iNdEx = postIndex
4302 case 2:
4303 if wireType != 2 {
4304 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4305 }
4306 var stringLen uint64
4307 for shift := uint(0); ; shift += 7 {
4308 if shift >= 64 {
4309 return ErrIntOverflowGenerated
4310 }
4311 if iNdEx >= l {
4312 return io.ErrUnexpectedEOF
4313 }
4314 b := dAtA[iNdEx]
4315 iNdEx++
4316 stringLen |= uint64(b&0x7F) << shift
4317 if b < 0x80 {
4318 break
4319 }
4320 }
4321 intStringLen := int(stringLen)
4322 if intStringLen < 0 {
4323 return ErrInvalidLengthGenerated
4324 }
4325 postIndex := iNdEx + intStringLen
4326 if postIndex < 0 {
4327 return ErrInvalidLengthGenerated
4328 }
4329 if postIndex > l {
4330 return io.ErrUnexpectedEOF
4331 }
4332 m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
4333 iNdEx = postIndex
4334 case 3:
4335 if wireType != 2 {
4336 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4337 }
4338 var msglen int
4339 for shift := uint(0); ; shift += 7 {
4340 if shift >= 64 {
4341 return ErrIntOverflowGenerated
4342 }
4343 if iNdEx >= l {
4344 return io.ErrUnexpectedEOF
4345 }
4346 b := dAtA[iNdEx]
4347 iNdEx++
4348 msglen |= int(b&0x7F) << shift
4349 if b < 0x80 {
4350 break
4351 }
4352 }
4353 if msglen < 0 {
4354 return ErrInvalidLengthGenerated
4355 }
4356 postIndex := iNdEx + msglen
4357 if postIndex < 0 {
4358 return ErrInvalidLengthGenerated
4359 }
4360 if postIndex > l {
4361 return io.ErrUnexpectedEOF
4362 }
4363 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4364 return err
4365 }
4366 iNdEx = postIndex
4367 case 4:
4368 if wireType != 2 {
4369 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4370 }
4371 var stringLen uint64
4372 for shift := uint(0); ; shift += 7 {
4373 if shift >= 64 {
4374 return ErrIntOverflowGenerated
4375 }
4376 if iNdEx >= l {
4377 return io.ErrUnexpectedEOF
4378 }
4379 b := dAtA[iNdEx]
4380 iNdEx++
4381 stringLen |= uint64(b&0x7F) << shift
4382 if b < 0x80 {
4383 break
4384 }
4385 }
4386 intStringLen := int(stringLen)
4387 if intStringLen < 0 {
4388 return ErrInvalidLengthGenerated
4389 }
4390 postIndex := iNdEx + intStringLen
4391 if postIndex < 0 {
4392 return ErrInvalidLengthGenerated
4393 }
4394 if postIndex > l {
4395 return io.ErrUnexpectedEOF
4396 }
4397 m.Reason = string(dAtA[iNdEx:postIndex])
4398 iNdEx = postIndex
4399 case 5:
4400 if wireType != 2 {
4401 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
4402 }
4403 var stringLen uint64
4404 for shift := uint(0); ; shift += 7 {
4405 if shift >= 64 {
4406 return ErrIntOverflowGenerated
4407 }
4408 if iNdEx >= l {
4409 return io.ErrUnexpectedEOF
4410 }
4411 b := dAtA[iNdEx]
4412 iNdEx++
4413 stringLen |= uint64(b&0x7F) << shift
4414 if b < 0x80 {
4415 break
4416 }
4417 }
4418 intStringLen := int(stringLen)
4419 if intStringLen < 0 {
4420 return ErrInvalidLengthGenerated
4421 }
4422 postIndex := iNdEx + intStringLen
4423 if postIndex < 0 {
4424 return ErrInvalidLengthGenerated
4425 }
4426 if postIndex > l {
4427 return io.ErrUnexpectedEOF
4428 }
4429 m.Message = string(dAtA[iNdEx:postIndex])
4430 iNdEx = postIndex
4431 default:
4432 iNdEx = preIndex
4433 skippy, err := skipGenerated(dAtA[iNdEx:])
4434 if err != nil {
4435 return err
4436 }
4437 if (skippy < 0) || (iNdEx+skippy) < 0 {
4438 return ErrInvalidLengthGenerated
4439 }
4440 if (iNdEx + skippy) > l {
4441 return io.ErrUnexpectedEOF
4442 }
4443 iNdEx += skippy
4444 }
4445 }
4446
4447 if iNdEx > l {
4448 return io.ErrUnexpectedEOF
4449 }
4450 return nil
4451 }
4452 func (m *PriorityLevelConfigurationList) Unmarshal(dAtA []byte) error {
4453 l := len(dAtA)
4454 iNdEx := 0
4455 for iNdEx < l {
4456 preIndex := iNdEx
4457 var wire uint64
4458 for shift := uint(0); ; shift += 7 {
4459 if shift >= 64 {
4460 return ErrIntOverflowGenerated
4461 }
4462 if iNdEx >= l {
4463 return io.ErrUnexpectedEOF
4464 }
4465 b := dAtA[iNdEx]
4466 iNdEx++
4467 wire |= uint64(b&0x7F) << shift
4468 if b < 0x80 {
4469 break
4470 }
4471 }
4472 fieldNum := int32(wire >> 3)
4473 wireType := int(wire & 0x7)
4474 if wireType == 4 {
4475 return fmt.Errorf("proto: PriorityLevelConfigurationList: wiretype end group for non-group")
4476 }
4477 if fieldNum <= 0 {
4478 return fmt.Errorf("proto: PriorityLevelConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
4479 }
4480 switch fieldNum {
4481 case 1:
4482 if wireType != 2 {
4483 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4484 }
4485 var msglen int
4486 for shift := uint(0); ; shift += 7 {
4487 if shift >= 64 {
4488 return ErrIntOverflowGenerated
4489 }
4490 if iNdEx >= l {
4491 return io.ErrUnexpectedEOF
4492 }
4493 b := dAtA[iNdEx]
4494 iNdEx++
4495 msglen |= int(b&0x7F) << shift
4496 if b < 0x80 {
4497 break
4498 }
4499 }
4500 if msglen < 0 {
4501 return ErrInvalidLengthGenerated
4502 }
4503 postIndex := iNdEx + msglen
4504 if postIndex < 0 {
4505 return ErrInvalidLengthGenerated
4506 }
4507 if postIndex > l {
4508 return io.ErrUnexpectedEOF
4509 }
4510 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4511 return err
4512 }
4513 iNdEx = postIndex
4514 case 2:
4515 if wireType != 2 {
4516 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4517 }
4518 var msglen int
4519 for shift := uint(0); ; shift += 7 {
4520 if shift >= 64 {
4521 return ErrIntOverflowGenerated
4522 }
4523 if iNdEx >= l {
4524 return io.ErrUnexpectedEOF
4525 }
4526 b := dAtA[iNdEx]
4527 iNdEx++
4528 msglen |= int(b&0x7F) << shift
4529 if b < 0x80 {
4530 break
4531 }
4532 }
4533 if msglen < 0 {
4534 return ErrInvalidLengthGenerated
4535 }
4536 postIndex := iNdEx + msglen
4537 if postIndex < 0 {
4538 return ErrInvalidLengthGenerated
4539 }
4540 if postIndex > l {
4541 return io.ErrUnexpectedEOF
4542 }
4543 m.Items = append(m.Items, PriorityLevelConfiguration{})
4544 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4545 return err
4546 }
4547 iNdEx = postIndex
4548 default:
4549 iNdEx = preIndex
4550 skippy, err := skipGenerated(dAtA[iNdEx:])
4551 if err != nil {
4552 return err
4553 }
4554 if (skippy < 0) || (iNdEx+skippy) < 0 {
4555 return ErrInvalidLengthGenerated
4556 }
4557 if (iNdEx + skippy) > l {
4558 return io.ErrUnexpectedEOF
4559 }
4560 iNdEx += skippy
4561 }
4562 }
4563
4564 if iNdEx > l {
4565 return io.ErrUnexpectedEOF
4566 }
4567 return nil
4568 }
4569 func (m *PriorityLevelConfigurationReference) Unmarshal(dAtA []byte) error {
4570 l := len(dAtA)
4571 iNdEx := 0
4572 for iNdEx < l {
4573 preIndex := iNdEx
4574 var wire uint64
4575 for shift := uint(0); ; shift += 7 {
4576 if shift >= 64 {
4577 return ErrIntOverflowGenerated
4578 }
4579 if iNdEx >= l {
4580 return io.ErrUnexpectedEOF
4581 }
4582 b := dAtA[iNdEx]
4583 iNdEx++
4584 wire |= uint64(b&0x7F) << shift
4585 if b < 0x80 {
4586 break
4587 }
4588 }
4589 fieldNum := int32(wire >> 3)
4590 wireType := int(wire & 0x7)
4591 if wireType == 4 {
4592 return fmt.Errorf("proto: PriorityLevelConfigurationReference: wiretype end group for non-group")
4593 }
4594 if fieldNum <= 0 {
4595 return fmt.Errorf("proto: PriorityLevelConfigurationReference: illegal tag %d (wire type %d)", fieldNum, wire)
4596 }
4597 switch fieldNum {
4598 case 1:
4599 if wireType != 2 {
4600 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4601 }
4602 var stringLen uint64
4603 for shift := uint(0); ; shift += 7 {
4604 if shift >= 64 {
4605 return ErrIntOverflowGenerated
4606 }
4607 if iNdEx >= l {
4608 return io.ErrUnexpectedEOF
4609 }
4610 b := dAtA[iNdEx]
4611 iNdEx++
4612 stringLen |= uint64(b&0x7F) << shift
4613 if b < 0x80 {
4614 break
4615 }
4616 }
4617 intStringLen := int(stringLen)
4618 if intStringLen < 0 {
4619 return ErrInvalidLengthGenerated
4620 }
4621 postIndex := iNdEx + intStringLen
4622 if postIndex < 0 {
4623 return ErrInvalidLengthGenerated
4624 }
4625 if postIndex > l {
4626 return io.ErrUnexpectedEOF
4627 }
4628 m.Name = string(dAtA[iNdEx:postIndex])
4629 iNdEx = postIndex
4630 default:
4631 iNdEx = preIndex
4632 skippy, err := skipGenerated(dAtA[iNdEx:])
4633 if err != nil {
4634 return err
4635 }
4636 if (skippy < 0) || (iNdEx+skippy) < 0 {
4637 return ErrInvalidLengthGenerated
4638 }
4639 if (iNdEx + skippy) > l {
4640 return io.ErrUnexpectedEOF
4641 }
4642 iNdEx += skippy
4643 }
4644 }
4645
4646 if iNdEx > l {
4647 return io.ErrUnexpectedEOF
4648 }
4649 return nil
4650 }
4651 func (m *PriorityLevelConfigurationSpec) Unmarshal(dAtA []byte) error {
4652 l := len(dAtA)
4653 iNdEx := 0
4654 for iNdEx < l {
4655 preIndex := iNdEx
4656 var wire uint64
4657 for shift := uint(0); ; shift += 7 {
4658 if shift >= 64 {
4659 return ErrIntOverflowGenerated
4660 }
4661 if iNdEx >= l {
4662 return io.ErrUnexpectedEOF
4663 }
4664 b := dAtA[iNdEx]
4665 iNdEx++
4666 wire |= uint64(b&0x7F) << shift
4667 if b < 0x80 {
4668 break
4669 }
4670 }
4671 fieldNum := int32(wire >> 3)
4672 wireType := int(wire & 0x7)
4673 if wireType == 4 {
4674 return fmt.Errorf("proto: PriorityLevelConfigurationSpec: wiretype end group for non-group")
4675 }
4676 if fieldNum <= 0 {
4677 return fmt.Errorf("proto: PriorityLevelConfigurationSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4678 }
4679 switch fieldNum {
4680 case 1:
4681 if wireType != 2 {
4682 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4683 }
4684 var stringLen uint64
4685 for shift := uint(0); ; shift += 7 {
4686 if shift >= 64 {
4687 return ErrIntOverflowGenerated
4688 }
4689 if iNdEx >= l {
4690 return io.ErrUnexpectedEOF
4691 }
4692 b := dAtA[iNdEx]
4693 iNdEx++
4694 stringLen |= uint64(b&0x7F) << shift
4695 if b < 0x80 {
4696 break
4697 }
4698 }
4699 intStringLen := int(stringLen)
4700 if intStringLen < 0 {
4701 return ErrInvalidLengthGenerated
4702 }
4703 postIndex := iNdEx + intStringLen
4704 if postIndex < 0 {
4705 return ErrInvalidLengthGenerated
4706 }
4707 if postIndex > l {
4708 return io.ErrUnexpectedEOF
4709 }
4710 m.Type = PriorityLevelEnablement(dAtA[iNdEx:postIndex])
4711 iNdEx = postIndex
4712 case 2:
4713 if wireType != 2 {
4714 return fmt.Errorf("proto: wrong wireType = %d for field Limited", wireType)
4715 }
4716 var msglen int
4717 for shift := uint(0); ; shift += 7 {
4718 if shift >= 64 {
4719 return ErrIntOverflowGenerated
4720 }
4721 if iNdEx >= l {
4722 return io.ErrUnexpectedEOF
4723 }
4724 b := dAtA[iNdEx]
4725 iNdEx++
4726 msglen |= int(b&0x7F) << shift
4727 if b < 0x80 {
4728 break
4729 }
4730 }
4731 if msglen < 0 {
4732 return ErrInvalidLengthGenerated
4733 }
4734 postIndex := iNdEx + msglen
4735 if postIndex < 0 {
4736 return ErrInvalidLengthGenerated
4737 }
4738 if postIndex > l {
4739 return io.ErrUnexpectedEOF
4740 }
4741 if m.Limited == nil {
4742 m.Limited = &LimitedPriorityLevelConfiguration{}
4743 }
4744 if err := m.Limited.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4745 return err
4746 }
4747 iNdEx = postIndex
4748 case 3:
4749 if wireType != 2 {
4750 return fmt.Errorf("proto: wrong wireType = %d for field Exempt", wireType)
4751 }
4752 var msglen int
4753 for shift := uint(0); ; shift += 7 {
4754 if shift >= 64 {
4755 return ErrIntOverflowGenerated
4756 }
4757 if iNdEx >= l {
4758 return io.ErrUnexpectedEOF
4759 }
4760 b := dAtA[iNdEx]
4761 iNdEx++
4762 msglen |= int(b&0x7F) << shift
4763 if b < 0x80 {
4764 break
4765 }
4766 }
4767 if msglen < 0 {
4768 return ErrInvalidLengthGenerated
4769 }
4770 postIndex := iNdEx + msglen
4771 if postIndex < 0 {
4772 return ErrInvalidLengthGenerated
4773 }
4774 if postIndex > l {
4775 return io.ErrUnexpectedEOF
4776 }
4777 if m.Exempt == nil {
4778 m.Exempt = &ExemptPriorityLevelConfiguration{}
4779 }
4780 if err := m.Exempt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4781 return err
4782 }
4783 iNdEx = postIndex
4784 default:
4785 iNdEx = preIndex
4786 skippy, err := skipGenerated(dAtA[iNdEx:])
4787 if err != nil {
4788 return err
4789 }
4790 if (skippy < 0) || (iNdEx+skippy) < 0 {
4791 return ErrInvalidLengthGenerated
4792 }
4793 if (iNdEx + skippy) > l {
4794 return io.ErrUnexpectedEOF
4795 }
4796 iNdEx += skippy
4797 }
4798 }
4799
4800 if iNdEx > l {
4801 return io.ErrUnexpectedEOF
4802 }
4803 return nil
4804 }
4805 func (m *PriorityLevelConfigurationStatus) Unmarshal(dAtA []byte) error {
4806 l := len(dAtA)
4807 iNdEx := 0
4808 for iNdEx < l {
4809 preIndex := iNdEx
4810 var wire uint64
4811 for shift := uint(0); ; shift += 7 {
4812 if shift >= 64 {
4813 return ErrIntOverflowGenerated
4814 }
4815 if iNdEx >= l {
4816 return io.ErrUnexpectedEOF
4817 }
4818 b := dAtA[iNdEx]
4819 iNdEx++
4820 wire |= uint64(b&0x7F) << shift
4821 if b < 0x80 {
4822 break
4823 }
4824 }
4825 fieldNum := int32(wire >> 3)
4826 wireType := int(wire & 0x7)
4827 if wireType == 4 {
4828 return fmt.Errorf("proto: PriorityLevelConfigurationStatus: wiretype end group for non-group")
4829 }
4830 if fieldNum <= 0 {
4831 return fmt.Errorf("proto: PriorityLevelConfigurationStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4832 }
4833 switch fieldNum {
4834 case 1:
4835 if wireType != 2 {
4836 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
4837 }
4838 var msglen int
4839 for shift := uint(0); ; shift += 7 {
4840 if shift >= 64 {
4841 return ErrIntOverflowGenerated
4842 }
4843 if iNdEx >= l {
4844 return io.ErrUnexpectedEOF
4845 }
4846 b := dAtA[iNdEx]
4847 iNdEx++
4848 msglen |= int(b&0x7F) << shift
4849 if b < 0x80 {
4850 break
4851 }
4852 }
4853 if msglen < 0 {
4854 return ErrInvalidLengthGenerated
4855 }
4856 postIndex := iNdEx + msglen
4857 if postIndex < 0 {
4858 return ErrInvalidLengthGenerated
4859 }
4860 if postIndex > l {
4861 return io.ErrUnexpectedEOF
4862 }
4863 m.Conditions = append(m.Conditions, PriorityLevelConfigurationCondition{})
4864 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4865 return err
4866 }
4867 iNdEx = postIndex
4868 default:
4869 iNdEx = preIndex
4870 skippy, err := skipGenerated(dAtA[iNdEx:])
4871 if err != nil {
4872 return err
4873 }
4874 if (skippy < 0) || (iNdEx+skippy) < 0 {
4875 return ErrInvalidLengthGenerated
4876 }
4877 if (iNdEx + skippy) > l {
4878 return io.ErrUnexpectedEOF
4879 }
4880 iNdEx += skippy
4881 }
4882 }
4883
4884 if iNdEx > l {
4885 return io.ErrUnexpectedEOF
4886 }
4887 return nil
4888 }
4889 func (m *QueuingConfiguration) Unmarshal(dAtA []byte) error {
4890 l := len(dAtA)
4891 iNdEx := 0
4892 for iNdEx < l {
4893 preIndex := iNdEx
4894 var wire uint64
4895 for shift := uint(0); ; shift += 7 {
4896 if shift >= 64 {
4897 return ErrIntOverflowGenerated
4898 }
4899 if iNdEx >= l {
4900 return io.ErrUnexpectedEOF
4901 }
4902 b := dAtA[iNdEx]
4903 iNdEx++
4904 wire |= uint64(b&0x7F) << shift
4905 if b < 0x80 {
4906 break
4907 }
4908 }
4909 fieldNum := int32(wire >> 3)
4910 wireType := int(wire & 0x7)
4911 if wireType == 4 {
4912 return fmt.Errorf("proto: QueuingConfiguration: wiretype end group for non-group")
4913 }
4914 if fieldNum <= 0 {
4915 return fmt.Errorf("proto: QueuingConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
4916 }
4917 switch fieldNum {
4918 case 1:
4919 if wireType != 0 {
4920 return fmt.Errorf("proto: wrong wireType = %d for field Queues", wireType)
4921 }
4922 m.Queues = 0
4923 for shift := uint(0); ; shift += 7 {
4924 if shift >= 64 {
4925 return ErrIntOverflowGenerated
4926 }
4927 if iNdEx >= l {
4928 return io.ErrUnexpectedEOF
4929 }
4930 b := dAtA[iNdEx]
4931 iNdEx++
4932 m.Queues |= int32(b&0x7F) << shift
4933 if b < 0x80 {
4934 break
4935 }
4936 }
4937 case 2:
4938 if wireType != 0 {
4939 return fmt.Errorf("proto: wrong wireType = %d for field HandSize", wireType)
4940 }
4941 m.HandSize = 0
4942 for shift := uint(0); ; shift += 7 {
4943 if shift >= 64 {
4944 return ErrIntOverflowGenerated
4945 }
4946 if iNdEx >= l {
4947 return io.ErrUnexpectedEOF
4948 }
4949 b := dAtA[iNdEx]
4950 iNdEx++
4951 m.HandSize |= int32(b&0x7F) << shift
4952 if b < 0x80 {
4953 break
4954 }
4955 }
4956 case 3:
4957 if wireType != 0 {
4958 return fmt.Errorf("proto: wrong wireType = %d for field QueueLengthLimit", wireType)
4959 }
4960 m.QueueLengthLimit = 0
4961 for shift := uint(0); ; shift += 7 {
4962 if shift >= 64 {
4963 return ErrIntOverflowGenerated
4964 }
4965 if iNdEx >= l {
4966 return io.ErrUnexpectedEOF
4967 }
4968 b := dAtA[iNdEx]
4969 iNdEx++
4970 m.QueueLengthLimit |= int32(b&0x7F) << shift
4971 if b < 0x80 {
4972 break
4973 }
4974 }
4975 default:
4976 iNdEx = preIndex
4977 skippy, err := skipGenerated(dAtA[iNdEx:])
4978 if err != nil {
4979 return err
4980 }
4981 if (skippy < 0) || (iNdEx+skippy) < 0 {
4982 return ErrInvalidLengthGenerated
4983 }
4984 if (iNdEx + skippy) > l {
4985 return io.ErrUnexpectedEOF
4986 }
4987 iNdEx += skippy
4988 }
4989 }
4990
4991 if iNdEx > l {
4992 return io.ErrUnexpectedEOF
4993 }
4994 return nil
4995 }
4996 func (m *ResourcePolicyRule) Unmarshal(dAtA []byte) error {
4997 l := len(dAtA)
4998 iNdEx := 0
4999 for iNdEx < l {
5000 preIndex := iNdEx
5001 var wire uint64
5002 for shift := uint(0); ; shift += 7 {
5003 if shift >= 64 {
5004 return ErrIntOverflowGenerated
5005 }
5006 if iNdEx >= l {
5007 return io.ErrUnexpectedEOF
5008 }
5009 b := dAtA[iNdEx]
5010 iNdEx++
5011 wire |= uint64(b&0x7F) << shift
5012 if b < 0x80 {
5013 break
5014 }
5015 }
5016 fieldNum := int32(wire >> 3)
5017 wireType := int(wire & 0x7)
5018 if wireType == 4 {
5019 return fmt.Errorf("proto: ResourcePolicyRule: wiretype end group for non-group")
5020 }
5021 if fieldNum <= 0 {
5022 return fmt.Errorf("proto: ResourcePolicyRule: illegal tag %d (wire type %d)", fieldNum, wire)
5023 }
5024 switch fieldNum {
5025 case 1:
5026 if wireType != 2 {
5027 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
5028 }
5029 var stringLen uint64
5030 for shift := uint(0); ; shift += 7 {
5031 if shift >= 64 {
5032 return ErrIntOverflowGenerated
5033 }
5034 if iNdEx >= l {
5035 return io.ErrUnexpectedEOF
5036 }
5037 b := dAtA[iNdEx]
5038 iNdEx++
5039 stringLen |= uint64(b&0x7F) << shift
5040 if b < 0x80 {
5041 break
5042 }
5043 }
5044 intStringLen := int(stringLen)
5045 if intStringLen < 0 {
5046 return ErrInvalidLengthGenerated
5047 }
5048 postIndex := iNdEx + intStringLen
5049 if postIndex < 0 {
5050 return ErrInvalidLengthGenerated
5051 }
5052 if postIndex > l {
5053 return io.ErrUnexpectedEOF
5054 }
5055 m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex]))
5056 iNdEx = postIndex
5057 case 2:
5058 if wireType != 2 {
5059 return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
5060 }
5061 var stringLen uint64
5062 for shift := uint(0); ; shift += 7 {
5063 if shift >= 64 {
5064 return ErrIntOverflowGenerated
5065 }
5066 if iNdEx >= l {
5067 return io.ErrUnexpectedEOF
5068 }
5069 b := dAtA[iNdEx]
5070 iNdEx++
5071 stringLen |= uint64(b&0x7F) << shift
5072 if b < 0x80 {
5073 break
5074 }
5075 }
5076 intStringLen := int(stringLen)
5077 if intStringLen < 0 {
5078 return ErrInvalidLengthGenerated
5079 }
5080 postIndex := iNdEx + intStringLen
5081 if postIndex < 0 {
5082 return ErrInvalidLengthGenerated
5083 }
5084 if postIndex > l {
5085 return io.ErrUnexpectedEOF
5086 }
5087 m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
5088 iNdEx = postIndex
5089 case 3:
5090 if wireType != 2 {
5091 return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
5092 }
5093 var stringLen uint64
5094 for shift := uint(0); ; shift += 7 {
5095 if shift >= 64 {
5096 return ErrIntOverflowGenerated
5097 }
5098 if iNdEx >= l {
5099 return io.ErrUnexpectedEOF
5100 }
5101 b := dAtA[iNdEx]
5102 iNdEx++
5103 stringLen |= uint64(b&0x7F) << shift
5104 if b < 0x80 {
5105 break
5106 }
5107 }
5108 intStringLen := int(stringLen)
5109 if intStringLen < 0 {
5110 return ErrInvalidLengthGenerated
5111 }
5112 postIndex := iNdEx + intStringLen
5113 if postIndex < 0 {
5114 return ErrInvalidLengthGenerated
5115 }
5116 if postIndex > l {
5117 return io.ErrUnexpectedEOF
5118 }
5119 m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
5120 iNdEx = postIndex
5121 case 4:
5122 if wireType != 0 {
5123 return fmt.Errorf("proto: wrong wireType = %d for field ClusterScope", wireType)
5124 }
5125 var v int
5126 for shift := uint(0); ; shift += 7 {
5127 if shift >= 64 {
5128 return ErrIntOverflowGenerated
5129 }
5130 if iNdEx >= l {
5131 return io.ErrUnexpectedEOF
5132 }
5133 b := dAtA[iNdEx]
5134 iNdEx++
5135 v |= int(b&0x7F) << shift
5136 if b < 0x80 {
5137 break
5138 }
5139 }
5140 m.ClusterScope = bool(v != 0)
5141 case 5:
5142 if wireType != 2 {
5143 return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType)
5144 }
5145 var stringLen uint64
5146 for shift := uint(0); ; shift += 7 {
5147 if shift >= 64 {
5148 return ErrIntOverflowGenerated
5149 }
5150 if iNdEx >= l {
5151 return io.ErrUnexpectedEOF
5152 }
5153 b := dAtA[iNdEx]
5154 iNdEx++
5155 stringLen |= uint64(b&0x7F) << shift
5156 if b < 0x80 {
5157 break
5158 }
5159 }
5160 intStringLen := int(stringLen)
5161 if intStringLen < 0 {
5162 return ErrInvalidLengthGenerated
5163 }
5164 postIndex := iNdEx + intStringLen
5165 if postIndex < 0 {
5166 return ErrInvalidLengthGenerated
5167 }
5168 if postIndex > l {
5169 return io.ErrUnexpectedEOF
5170 }
5171 m.Namespaces = append(m.Namespaces, string(dAtA[iNdEx:postIndex]))
5172 iNdEx = postIndex
5173 default:
5174 iNdEx = preIndex
5175 skippy, err := skipGenerated(dAtA[iNdEx:])
5176 if err != nil {
5177 return err
5178 }
5179 if (skippy < 0) || (iNdEx+skippy) < 0 {
5180 return ErrInvalidLengthGenerated
5181 }
5182 if (iNdEx + skippy) > l {
5183 return io.ErrUnexpectedEOF
5184 }
5185 iNdEx += skippy
5186 }
5187 }
5188
5189 if iNdEx > l {
5190 return io.ErrUnexpectedEOF
5191 }
5192 return nil
5193 }
5194 func (m *ServiceAccountSubject) Unmarshal(dAtA []byte) error {
5195 l := len(dAtA)
5196 iNdEx := 0
5197 for iNdEx < l {
5198 preIndex := iNdEx
5199 var wire uint64
5200 for shift := uint(0); ; shift += 7 {
5201 if shift >= 64 {
5202 return ErrIntOverflowGenerated
5203 }
5204 if iNdEx >= l {
5205 return io.ErrUnexpectedEOF
5206 }
5207 b := dAtA[iNdEx]
5208 iNdEx++
5209 wire |= uint64(b&0x7F) << shift
5210 if b < 0x80 {
5211 break
5212 }
5213 }
5214 fieldNum := int32(wire >> 3)
5215 wireType := int(wire & 0x7)
5216 if wireType == 4 {
5217 return fmt.Errorf("proto: ServiceAccountSubject: wiretype end group for non-group")
5218 }
5219 if fieldNum <= 0 {
5220 return fmt.Errorf("proto: ServiceAccountSubject: illegal tag %d (wire type %d)", fieldNum, wire)
5221 }
5222 switch fieldNum {
5223 case 1:
5224 if wireType != 2 {
5225 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
5226 }
5227 var stringLen uint64
5228 for shift := uint(0); ; shift += 7 {
5229 if shift >= 64 {
5230 return ErrIntOverflowGenerated
5231 }
5232 if iNdEx >= l {
5233 return io.ErrUnexpectedEOF
5234 }
5235 b := dAtA[iNdEx]
5236 iNdEx++
5237 stringLen |= uint64(b&0x7F) << shift
5238 if b < 0x80 {
5239 break
5240 }
5241 }
5242 intStringLen := int(stringLen)
5243 if intStringLen < 0 {
5244 return ErrInvalidLengthGenerated
5245 }
5246 postIndex := iNdEx + intStringLen
5247 if postIndex < 0 {
5248 return ErrInvalidLengthGenerated
5249 }
5250 if postIndex > l {
5251 return io.ErrUnexpectedEOF
5252 }
5253 m.Namespace = string(dAtA[iNdEx:postIndex])
5254 iNdEx = postIndex
5255 case 2:
5256 if wireType != 2 {
5257 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5258 }
5259 var stringLen uint64
5260 for shift := uint(0); ; shift += 7 {
5261 if shift >= 64 {
5262 return ErrIntOverflowGenerated
5263 }
5264 if iNdEx >= l {
5265 return io.ErrUnexpectedEOF
5266 }
5267 b := dAtA[iNdEx]
5268 iNdEx++
5269 stringLen |= uint64(b&0x7F) << shift
5270 if b < 0x80 {
5271 break
5272 }
5273 }
5274 intStringLen := int(stringLen)
5275 if intStringLen < 0 {
5276 return ErrInvalidLengthGenerated
5277 }
5278 postIndex := iNdEx + intStringLen
5279 if postIndex < 0 {
5280 return ErrInvalidLengthGenerated
5281 }
5282 if postIndex > l {
5283 return io.ErrUnexpectedEOF
5284 }
5285 m.Name = string(dAtA[iNdEx:postIndex])
5286 iNdEx = postIndex
5287 default:
5288 iNdEx = preIndex
5289 skippy, err := skipGenerated(dAtA[iNdEx:])
5290 if err != nil {
5291 return err
5292 }
5293 if (skippy < 0) || (iNdEx+skippy) < 0 {
5294 return ErrInvalidLengthGenerated
5295 }
5296 if (iNdEx + skippy) > l {
5297 return io.ErrUnexpectedEOF
5298 }
5299 iNdEx += skippy
5300 }
5301 }
5302
5303 if iNdEx > l {
5304 return io.ErrUnexpectedEOF
5305 }
5306 return nil
5307 }
5308 func (m *Subject) Unmarshal(dAtA []byte) error {
5309 l := len(dAtA)
5310 iNdEx := 0
5311 for iNdEx < l {
5312 preIndex := iNdEx
5313 var wire uint64
5314 for shift := uint(0); ; shift += 7 {
5315 if shift >= 64 {
5316 return ErrIntOverflowGenerated
5317 }
5318 if iNdEx >= l {
5319 return io.ErrUnexpectedEOF
5320 }
5321 b := dAtA[iNdEx]
5322 iNdEx++
5323 wire |= uint64(b&0x7F) << shift
5324 if b < 0x80 {
5325 break
5326 }
5327 }
5328 fieldNum := int32(wire >> 3)
5329 wireType := int(wire & 0x7)
5330 if wireType == 4 {
5331 return fmt.Errorf("proto: Subject: wiretype end group for non-group")
5332 }
5333 if fieldNum <= 0 {
5334 return fmt.Errorf("proto: Subject: illegal tag %d (wire type %d)", fieldNum, wire)
5335 }
5336 switch fieldNum {
5337 case 1:
5338 if wireType != 2 {
5339 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
5340 }
5341 var stringLen uint64
5342 for shift := uint(0); ; shift += 7 {
5343 if shift >= 64 {
5344 return ErrIntOverflowGenerated
5345 }
5346 if iNdEx >= l {
5347 return io.ErrUnexpectedEOF
5348 }
5349 b := dAtA[iNdEx]
5350 iNdEx++
5351 stringLen |= uint64(b&0x7F) << shift
5352 if b < 0x80 {
5353 break
5354 }
5355 }
5356 intStringLen := int(stringLen)
5357 if intStringLen < 0 {
5358 return ErrInvalidLengthGenerated
5359 }
5360 postIndex := iNdEx + intStringLen
5361 if postIndex < 0 {
5362 return ErrInvalidLengthGenerated
5363 }
5364 if postIndex > l {
5365 return io.ErrUnexpectedEOF
5366 }
5367 m.Kind = SubjectKind(dAtA[iNdEx:postIndex])
5368 iNdEx = postIndex
5369 case 2:
5370 if wireType != 2 {
5371 return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
5372 }
5373 var msglen int
5374 for shift := uint(0); ; shift += 7 {
5375 if shift >= 64 {
5376 return ErrIntOverflowGenerated
5377 }
5378 if iNdEx >= l {
5379 return io.ErrUnexpectedEOF
5380 }
5381 b := dAtA[iNdEx]
5382 iNdEx++
5383 msglen |= int(b&0x7F) << shift
5384 if b < 0x80 {
5385 break
5386 }
5387 }
5388 if msglen < 0 {
5389 return ErrInvalidLengthGenerated
5390 }
5391 postIndex := iNdEx + msglen
5392 if postIndex < 0 {
5393 return ErrInvalidLengthGenerated
5394 }
5395 if postIndex > l {
5396 return io.ErrUnexpectedEOF
5397 }
5398 if m.User == nil {
5399 m.User = &UserSubject{}
5400 }
5401 if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5402 return err
5403 }
5404 iNdEx = postIndex
5405 case 3:
5406 if wireType != 2 {
5407 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
5408 }
5409 var msglen int
5410 for shift := uint(0); ; shift += 7 {
5411 if shift >= 64 {
5412 return ErrIntOverflowGenerated
5413 }
5414 if iNdEx >= l {
5415 return io.ErrUnexpectedEOF
5416 }
5417 b := dAtA[iNdEx]
5418 iNdEx++
5419 msglen |= int(b&0x7F) << shift
5420 if b < 0x80 {
5421 break
5422 }
5423 }
5424 if msglen < 0 {
5425 return ErrInvalidLengthGenerated
5426 }
5427 postIndex := iNdEx + msglen
5428 if postIndex < 0 {
5429 return ErrInvalidLengthGenerated
5430 }
5431 if postIndex > l {
5432 return io.ErrUnexpectedEOF
5433 }
5434 if m.Group == nil {
5435 m.Group = &GroupSubject{}
5436 }
5437 if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5438 return err
5439 }
5440 iNdEx = postIndex
5441 case 4:
5442 if wireType != 2 {
5443 return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccount", wireType)
5444 }
5445 var msglen int
5446 for shift := uint(0); ; shift += 7 {
5447 if shift >= 64 {
5448 return ErrIntOverflowGenerated
5449 }
5450 if iNdEx >= l {
5451 return io.ErrUnexpectedEOF
5452 }
5453 b := dAtA[iNdEx]
5454 iNdEx++
5455 msglen |= int(b&0x7F) << shift
5456 if b < 0x80 {
5457 break
5458 }
5459 }
5460 if msglen < 0 {
5461 return ErrInvalidLengthGenerated
5462 }
5463 postIndex := iNdEx + msglen
5464 if postIndex < 0 {
5465 return ErrInvalidLengthGenerated
5466 }
5467 if postIndex > l {
5468 return io.ErrUnexpectedEOF
5469 }
5470 if m.ServiceAccount == nil {
5471 m.ServiceAccount = &ServiceAccountSubject{}
5472 }
5473 if err := m.ServiceAccount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5474 return err
5475 }
5476 iNdEx = postIndex
5477 default:
5478 iNdEx = preIndex
5479 skippy, err := skipGenerated(dAtA[iNdEx:])
5480 if err != nil {
5481 return err
5482 }
5483 if (skippy < 0) || (iNdEx+skippy) < 0 {
5484 return ErrInvalidLengthGenerated
5485 }
5486 if (iNdEx + skippy) > l {
5487 return io.ErrUnexpectedEOF
5488 }
5489 iNdEx += skippy
5490 }
5491 }
5492
5493 if iNdEx > l {
5494 return io.ErrUnexpectedEOF
5495 }
5496 return nil
5497 }
5498 func (m *UserSubject) Unmarshal(dAtA []byte) error {
5499 l := len(dAtA)
5500 iNdEx := 0
5501 for iNdEx < l {
5502 preIndex := iNdEx
5503 var wire uint64
5504 for shift := uint(0); ; shift += 7 {
5505 if shift >= 64 {
5506 return ErrIntOverflowGenerated
5507 }
5508 if iNdEx >= l {
5509 return io.ErrUnexpectedEOF
5510 }
5511 b := dAtA[iNdEx]
5512 iNdEx++
5513 wire |= uint64(b&0x7F) << shift
5514 if b < 0x80 {
5515 break
5516 }
5517 }
5518 fieldNum := int32(wire >> 3)
5519 wireType := int(wire & 0x7)
5520 if wireType == 4 {
5521 return fmt.Errorf("proto: UserSubject: wiretype end group for non-group")
5522 }
5523 if fieldNum <= 0 {
5524 return fmt.Errorf("proto: UserSubject: illegal tag %d (wire type %d)", fieldNum, wire)
5525 }
5526 switch fieldNum {
5527 case 1:
5528 if wireType != 2 {
5529 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5530 }
5531 var stringLen uint64
5532 for shift := uint(0); ; shift += 7 {
5533 if shift >= 64 {
5534 return ErrIntOverflowGenerated
5535 }
5536 if iNdEx >= l {
5537 return io.ErrUnexpectedEOF
5538 }
5539 b := dAtA[iNdEx]
5540 iNdEx++
5541 stringLen |= uint64(b&0x7F) << shift
5542 if b < 0x80 {
5543 break
5544 }
5545 }
5546 intStringLen := int(stringLen)
5547 if intStringLen < 0 {
5548 return ErrInvalidLengthGenerated
5549 }
5550 postIndex := iNdEx + intStringLen
5551 if postIndex < 0 {
5552 return ErrInvalidLengthGenerated
5553 }
5554 if postIndex > l {
5555 return io.ErrUnexpectedEOF
5556 }
5557 m.Name = string(dAtA[iNdEx:postIndex])
5558 iNdEx = postIndex
5559 default:
5560 iNdEx = preIndex
5561 skippy, err := skipGenerated(dAtA[iNdEx:])
5562 if err != nil {
5563 return err
5564 }
5565 if (skippy < 0) || (iNdEx+skippy) < 0 {
5566 return ErrInvalidLengthGenerated
5567 }
5568 if (iNdEx + skippy) > l {
5569 return io.ErrUnexpectedEOF
5570 }
5571 iNdEx += skippy
5572 }
5573 }
5574
5575 if iNdEx > l {
5576 return io.ErrUnexpectedEOF
5577 }
5578 return nil
5579 }
5580 func skipGenerated(dAtA []byte) (n int, err error) {
5581 l := len(dAtA)
5582 iNdEx := 0
5583 depth := 0
5584 for iNdEx < l {
5585 var wire uint64
5586 for shift := uint(0); ; shift += 7 {
5587 if shift >= 64 {
5588 return 0, ErrIntOverflowGenerated
5589 }
5590 if iNdEx >= l {
5591 return 0, io.ErrUnexpectedEOF
5592 }
5593 b := dAtA[iNdEx]
5594 iNdEx++
5595 wire |= (uint64(b) & 0x7F) << shift
5596 if b < 0x80 {
5597 break
5598 }
5599 }
5600 wireType := int(wire & 0x7)
5601 switch wireType {
5602 case 0:
5603 for shift := uint(0); ; shift += 7 {
5604 if shift >= 64 {
5605 return 0, ErrIntOverflowGenerated
5606 }
5607 if iNdEx >= l {
5608 return 0, io.ErrUnexpectedEOF
5609 }
5610 iNdEx++
5611 if dAtA[iNdEx-1] < 0x80 {
5612 break
5613 }
5614 }
5615 case 1:
5616 iNdEx += 8
5617 case 2:
5618 var length int
5619 for shift := uint(0); ; shift += 7 {
5620 if shift >= 64 {
5621 return 0, ErrIntOverflowGenerated
5622 }
5623 if iNdEx >= l {
5624 return 0, io.ErrUnexpectedEOF
5625 }
5626 b := dAtA[iNdEx]
5627 iNdEx++
5628 length |= (int(b) & 0x7F) << shift
5629 if b < 0x80 {
5630 break
5631 }
5632 }
5633 if length < 0 {
5634 return 0, ErrInvalidLengthGenerated
5635 }
5636 iNdEx += length
5637 case 3:
5638 depth++
5639 case 4:
5640 if depth == 0 {
5641 return 0, ErrUnexpectedEndOfGroupGenerated
5642 }
5643 depth--
5644 case 5:
5645 iNdEx += 4
5646 default:
5647 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
5648 }
5649 if iNdEx < 0 {
5650 return 0, ErrInvalidLengthGenerated
5651 }
5652 if depth == 0 {
5653 return iNdEx, nil
5654 }
5655 }
5656 return 0, io.ErrUnexpectedEOF
5657 }
5658
5659 var (
5660 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
5661 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
5662 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
5663 )
5664
View as plain text