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