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