Debian Codegraph @

envoy/config/rbac/v3/rbac_vtproto.pb.go

raw
1 //go:build vtprotobuf
2 // +build vtprotobuf
3
4 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
5 // source: envoy/config/rbac/v3/rbac.proto
6
7 package rbacv3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 proto "google.golang.org/protobuf/proto"
12 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
13 )
14
15 const (
16 // Verify that this generated code is sufficiently up-to-date.
17 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
18 // Verify that runtime/protoimpl is sufficiently up-to-date.
19 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
20 )
21
22 func (m *RBAC_AuditLoggingOptions_AuditLoggerConfig) MarshalVTStrict() (dAtA []byte, err error) {
23 if m == nil {
24 return nil, nil
25 }
26 size := m.SizeVT()
27 dAtA = make([]byte, size)
28 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
29 if err != nil {
30 return nil, err
31 }
32 return dAtA[:n], nil
33 }
34
35 func (m *RBAC_AuditLoggingOptions_AuditLoggerConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *RBAC_AuditLoggingOptions_AuditLoggerConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
41 if m == nil {
42 return 0, nil
43 }
44 i := len(dAtA)
45 _ = i
46 var l int
47 _ = l
48 if m.unknownFields != nil {
49 i -= len(m.unknownFields)
50 copy(dAtA[i:], m.unknownFields)
51 }
52 if m.IsOptional {
53 i--
54 if m.IsOptional {
55 dAtA[i] = 1
56 } else {
57 dAtA[i] = 0
58 }
59 i--
60 dAtA[i] = 0x10
61 }
62 if m.AuditLogger != nil {
63 if vtmsg, ok := interface{}(m.AuditLogger).(interface {
64 MarshalToSizedBufferVTStrict([]byte) (int, error)
65 }); ok {
66 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
67 if err != nil {
68 return 0, err
69 }
70 i -= size
71 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
72 } else {
73 encoded, err := proto.Marshal(m.AuditLogger)
74 if err != nil {
75 return 0, err
76 }
77 i -= len(encoded)
78 copy(dAtA[i:], encoded)
79 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
80 }
81 i--
82 dAtA[i] = 0xa
83 }
84 return len(dAtA) - i, nil
85 }
86
87 func (m *RBAC_AuditLoggingOptions) MarshalVTStrict() (dAtA []byte, err error) {
88 if m == nil {
89 return nil, nil
90 }
91 size := m.SizeVT()
92 dAtA = make([]byte, size)
93 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
94 if err != nil {
95 return nil, err
96 }
97 return dAtA[:n], nil
98 }
99
100 func (m *RBAC_AuditLoggingOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
101 size := m.SizeVT()
102 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
103 }
104
105 func (m *RBAC_AuditLoggingOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
106 if m == nil {
107 return 0, nil
108 }
109 i := len(dAtA)
110 _ = i
111 var l int
112 _ = l
113 if m.unknownFields != nil {
114 i -= len(m.unknownFields)
115 copy(dAtA[i:], m.unknownFields)
116 }
117 if len(m.LoggerConfigs) > 0 {
118 for iNdEx := len(m.LoggerConfigs) - 1; iNdEx >= 0; iNdEx-- {
119 size, err := m.LoggerConfigs[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
120 if err != nil {
121 return 0, err
122 }
123 i -= size
124 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
125 i--
126 dAtA[i] = 0x12
127 }
128 }
129 if m.AuditCondition != 0 {
130 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.AuditCondition))
131 i--
132 dAtA[i] = 0x8
133 }
134 return len(dAtA) - i, nil
135 }
136
137 func (m *RBAC) MarshalVTStrict() (dAtA []byte, err error) {
138 if m == nil {
139 return nil, nil
140 }
141 size := m.SizeVT()
142 dAtA = make([]byte, size)
143 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
144 if err != nil {
145 return nil, err
146 }
147 return dAtA[:n], nil
148 }
149
150 func (m *RBAC) MarshalToVTStrict(dAtA []byte) (int, error) {
151 size := m.SizeVT()
152 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
153 }
154
155 func (m *RBAC) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
156 if m == nil {
157 return 0, nil
158 }
159 i := len(dAtA)
160 _ = i
161 var l int
162 _ = l
163 if m.unknownFields != nil {
164 i -= len(m.unknownFields)
165 copy(dAtA[i:], m.unknownFields)
166 }
167 if m.AuditLoggingOptions != nil {
168 size, err := m.AuditLoggingOptions.MarshalToSizedBufferVTStrict(dAtA[:i])
169 if err != nil {
170 return 0, err
171 }
172 i -= size
173 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
174 i--
175 dAtA[i] = 0x1a
176 }
177 if len(m.Policies) > 0 {
178 for k := range m.Policies {
179 v := m.Policies[k]
180 baseI := i
181 size, err := v.MarshalToSizedBufferVTStrict(dAtA[:i])
182 if err != nil {
183 return 0, err
184 }
185 i -= size
186 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
187 i--
188 dAtA[i] = 0x12
189 i -= len(k)
190 copy(dAtA[i:], k)
191 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
192 i--
193 dAtA[i] = 0xa
194 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
195 i--
196 dAtA[i] = 0x12
197 }
198 }
199 if m.Action != 0 {
200 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Action))
201 i--
202 dAtA[i] = 0x8
203 }
204 return len(dAtA) - i, nil
205 }
206
207 func (m *Policy) MarshalVTStrict() (dAtA []byte, err error) {
208 if m == nil {
209 return nil, nil
210 }
211 size := m.SizeVT()
212 dAtA = make([]byte, size)
213 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
214 if err != nil {
215 return nil, err
216 }
217 return dAtA[:n], nil
218 }
219
220 func (m *Policy) MarshalToVTStrict(dAtA []byte) (int, error) {
221 size := m.SizeVT()
222 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
223 }
224
225 func (m *Policy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
226 if m == nil {
227 return 0, nil
228 }
229 i := len(dAtA)
230 _ = i
231 var l int
232 _ = l
233 if m.unknownFields != nil {
234 i -= len(m.unknownFields)
235 copy(dAtA[i:], m.unknownFields)
236 }
237 if m.CheckedCondition != nil {
238 if vtmsg, ok := interface{}(m.CheckedCondition).(interface {
239 MarshalToSizedBufferVTStrict([]byte) (int, error)
240 }); ok {
241 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
242 if err != nil {
243 return 0, err
244 }
245 i -= size
246 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
247 } else {
248 encoded, err := proto.Marshal(m.CheckedCondition)
249 if err != nil {
250 return 0, err
251 }
252 i -= len(encoded)
253 copy(dAtA[i:], encoded)
254 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
255 }
256 i--
257 dAtA[i] = 0x22
258 }
259 if m.Condition != nil {
260 if vtmsg, ok := interface{}(m.Condition).(interface {
261 MarshalToSizedBufferVTStrict([]byte) (int, error)
262 }); ok {
263 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
264 if err != nil {
265 return 0, err
266 }
267 i -= size
268 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
269 } else {
270 encoded, err := proto.Marshal(m.Condition)
271 if err != nil {
272 return 0, err
273 }
274 i -= len(encoded)
275 copy(dAtA[i:], encoded)
276 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
277 }
278 i--
279 dAtA[i] = 0x1a
280 }
281 if len(m.Principals) > 0 {
282 for iNdEx := len(m.Principals) - 1; iNdEx >= 0; iNdEx-- {
283 size, err := m.Principals[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
284 if err != nil {
285 return 0, err
286 }
287 i -= size
288 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
289 i--
290 dAtA[i] = 0x12
291 }
292 }
293 if len(m.Permissions) > 0 {
294 for iNdEx := len(m.Permissions) - 1; iNdEx >= 0; iNdEx-- {
295 size, err := m.Permissions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
296 if err != nil {
297 return 0, err
298 }
299 i -= size
300 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
301 i--
302 dAtA[i] = 0xa
303 }
304 }
305 return len(dAtA) - i, nil
306 }
307
308 func (m *SourcedMetadata) MarshalVTStrict() (dAtA []byte, err error) {
309 if m == nil {
310 return nil, nil
311 }
312 size := m.SizeVT()
313 dAtA = make([]byte, size)
314 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
315 if err != nil {
316 return nil, err
317 }
318 return dAtA[:n], nil
319 }
320
321 func (m *SourcedMetadata) MarshalToVTStrict(dAtA []byte) (int, error) {
322 size := m.SizeVT()
323 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
324 }
325
326 func (m *SourcedMetadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
327 if m == nil {
328 return 0, nil
329 }
330 i := len(dAtA)
331 _ = i
332 var l int
333 _ = l
334 if m.unknownFields != nil {
335 i -= len(m.unknownFields)
336 copy(dAtA[i:], m.unknownFields)
337 }
338 if m.MetadataSource != 0 {
339 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MetadataSource))
340 i--
341 dAtA[i] = 0x10
342 }
343 if m.MetadataMatcher != nil {
344 if vtmsg, ok := interface{}(m.MetadataMatcher).(interface {
345 MarshalToSizedBufferVTStrict([]byte) (int, error)
346 }); ok {
347 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
348 if err != nil {
349 return 0, err
350 }
351 i -= size
352 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
353 } else {
354 encoded, err := proto.Marshal(m.MetadataMatcher)
355 if err != nil {
356 return 0, err
357 }
358 i -= len(encoded)
359 copy(dAtA[i:], encoded)
360 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
361 }
362 i--
363 dAtA[i] = 0xa
364 }
365 return len(dAtA) - i, nil
366 }
367
368 func (m *Permission_Set) MarshalVTStrict() (dAtA []byte, err error) {
369 if m == nil {
370 return nil, nil
371 }
372 size := m.SizeVT()
373 dAtA = make([]byte, size)
374 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
375 if err != nil {
376 return nil, err
377 }
378 return dAtA[:n], nil
379 }
380
381 func (m *Permission_Set) MarshalToVTStrict(dAtA []byte) (int, error) {
382 size := m.SizeVT()
383 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
384 }
385
386 func (m *Permission_Set) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
387 if m == nil {
388 return 0, nil
389 }
390 i := len(dAtA)
391 _ = i
392 var l int
393 _ = l
394 if m.unknownFields != nil {
395 i -= len(m.unknownFields)
396 copy(dAtA[i:], m.unknownFields)
397 }
398 if len(m.Rules) > 0 {
399 for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
400 size, err := m.Rules[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
401 if err != nil {
402 return 0, err
403 }
404 i -= size
405 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
406 i--
407 dAtA[i] = 0xa
408 }
409 }
410 return len(dAtA) - i, nil
411 }
412
413 func (m *Permission) MarshalVTStrict() (dAtA []byte, err error) {
414 if m == nil {
415 return nil, nil
416 }
417 size := m.SizeVT()
418 dAtA = make([]byte, size)
419 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
420 if err != nil {
421 return nil, err
422 }
423 return dAtA[:n], nil
424 }
425
426 func (m *Permission) MarshalToVTStrict(dAtA []byte) (int, error) {
427 size := m.SizeVT()
428 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
429 }
430
431 func (m *Permission) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
432 if m == nil {
433 return 0, nil
434 }
435 i := len(dAtA)
436 _ = i
437 var l int
438 _ = l
439 if m.unknownFields != nil {
440 i -= len(m.unknownFields)
441 copy(dAtA[i:], m.unknownFields)
442 }
443 if msg, ok := m.Rule.(*Permission_SourcedMetadata); ok {
444 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
445 if err != nil {
446 return 0, err
447 }
448 i -= size
449 }
450 if msg, ok := m.Rule.(*Permission_UriTemplate); ok {
451 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
452 if err != nil {
453 return 0, err
454 }
455 i -= size
456 }
457 if msg, ok := m.Rule.(*Permission_Matcher); ok {
458 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
459 if err != nil {
460 return 0, err
461 }
462 i -= size
463 }
464 if msg, ok := m.Rule.(*Permission_DestinationPortRange); ok {
465 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
466 if err != nil {
467 return 0, err
468 }
469 i -= size
470 }
471 if msg, ok := m.Rule.(*Permission_UrlPath); ok {
472 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
473 if err != nil {
474 return 0, err
475 }
476 i -= size
477 }
478 if msg, ok := m.Rule.(*Permission_RequestedServerName); ok {
479 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
480 if err != nil {
481 return 0, err
482 }
483 i -= size
484 }
485 if msg, ok := m.Rule.(*Permission_NotRule); ok {
486 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
487 if err != nil {
488 return 0, err
489 }
490 i -= size
491 }
492 if msg, ok := m.Rule.(*Permission_Metadata); ok {
493 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
494 if err != nil {
495 return 0, err
496 }
497 i -= size
498 }
499 if msg, ok := m.Rule.(*Permission_DestinationPort); ok {
500 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
501 if err != nil {
502 return 0, err
503 }
504 i -= size
505 }
506 if msg, ok := m.Rule.(*Permission_DestinationIp); ok {
507 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
508 if err != nil {
509 return 0, err
510 }
511 i -= size
512 }
513 if msg, ok := m.Rule.(*Permission_Header); ok {
514 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
515 if err != nil {
516 return 0, err
517 }
518 i -= size
519 }
520 if msg, ok := m.Rule.(*Permission_Any); ok {
521 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
522 if err != nil {
523 return 0, err
524 }
525 i -= size
526 }
527 if msg, ok := m.Rule.(*Permission_OrRules); ok {
528 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
529 if err != nil {
530 return 0, err
531 }
532 i -= size
533 }
534 if msg, ok := m.Rule.(*Permission_AndRules); ok {
535 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
536 if err != nil {
537 return 0, err
538 }
539 i -= size
540 }
541 return len(dAtA) - i, nil
542 }
543
544 func (m *Permission_AndRules) MarshalToVTStrict(dAtA []byte) (int, error) {
545 size := m.SizeVT()
546 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
547 }
548
549 func (m *Permission_AndRules) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
550 i := len(dAtA)
551 if m.AndRules != nil {
552 size, err := m.AndRules.MarshalToSizedBufferVTStrict(dAtA[:i])
553 if err != nil {
554 return 0, err
555 }
556 i -= size
557 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
558 i--
559 dAtA[i] = 0xa
560 } else {
561 i = protohelpers.EncodeVarint(dAtA, i, 0)
562 i--
563 dAtA[i] = 0xa
564 }
565 return len(dAtA) - i, nil
566 }
567 func (m *Permission_OrRules) MarshalToVTStrict(dAtA []byte) (int, error) {
568 size := m.SizeVT()
569 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
570 }
571
572 func (m *Permission_OrRules) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
573 i := len(dAtA)
574 if m.OrRules != nil {
575 size, err := m.OrRules.MarshalToSizedBufferVTStrict(dAtA[:i])
576 if err != nil {
577 return 0, err
578 }
579 i -= size
580 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
581 i--
582 dAtA[i] = 0x12
583 } else {
584 i = protohelpers.EncodeVarint(dAtA, i, 0)
585 i--
586 dAtA[i] = 0x12
587 }
588 return len(dAtA) - i, nil
589 }
590 func (m *Permission_Any) MarshalToVTStrict(dAtA []byte) (int, error) {
591 size := m.SizeVT()
592 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
593 }
594
595 func (m *Permission_Any) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
596 i := len(dAtA)
597 i--
598 if m.Any {
599 dAtA[i] = 1
600 } else {
601 dAtA[i] = 0
602 }
603 i--
604 dAtA[i] = 0x18
605 return len(dAtA) - i, nil
606 }
607 func (m *Permission_Header) MarshalToVTStrict(dAtA []byte) (int, error) {
608 size := m.SizeVT()
609 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
610 }
611
612 func (m *Permission_Header) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
613 i := len(dAtA)
614 if m.Header != nil {
615 if vtmsg, ok := interface{}(m.Header).(interface {
616 MarshalToSizedBufferVTStrict([]byte) (int, error)
617 }); ok {
618 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
619 if err != nil {
620 return 0, err
621 }
622 i -= size
623 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
624 } else {
625 encoded, err := proto.Marshal(m.Header)
626 if err != nil {
627 return 0, err
628 }
629 i -= len(encoded)
630 copy(dAtA[i:], encoded)
631 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
632 }
633 i--
634 dAtA[i] = 0x22
635 } else {
636 i = protohelpers.EncodeVarint(dAtA, i, 0)
637 i--
638 dAtA[i] = 0x22
639 }
640 return len(dAtA) - i, nil
641 }
642 func (m *Permission_DestinationIp) MarshalToVTStrict(dAtA []byte) (int, error) {
643 size := m.SizeVT()
644 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
645 }
646
647 func (m *Permission_DestinationIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
648 i := len(dAtA)
649 if m.DestinationIp != nil {
650 if vtmsg, ok := interface{}(m.DestinationIp).(interface {
651 MarshalToSizedBufferVTStrict([]byte) (int, error)
652 }); ok {
653 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
654 if err != nil {
655 return 0, err
656 }
657 i -= size
658 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
659 } else {
660 encoded, err := proto.Marshal(m.DestinationIp)
661 if err != nil {
662 return 0, err
663 }
664 i -= len(encoded)
665 copy(dAtA[i:], encoded)
666 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
667 }
668 i--
669 dAtA[i] = 0x2a
670 } else {
671 i = protohelpers.EncodeVarint(dAtA, i, 0)
672 i--
673 dAtA[i] = 0x2a
674 }
675 return len(dAtA) - i, nil
676 }
677 func (m *Permission_DestinationPort) MarshalToVTStrict(dAtA []byte) (int, error) {
678 size := m.SizeVT()
679 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
680 }
681
682 func (m *Permission_DestinationPort) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
683 i := len(dAtA)
684 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DestinationPort))
685 i--
686 dAtA[i] = 0x30
687 return len(dAtA) - i, nil
688 }
689 func (m *Permission_Metadata) MarshalToVTStrict(dAtA []byte) (int, error) {
690 size := m.SizeVT()
691 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
692 }
693
694 func (m *Permission_Metadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
695 i := len(dAtA)
696 if m.Metadata != nil {
697 if vtmsg, ok := interface{}(m.Metadata).(interface {
698 MarshalToSizedBufferVTStrict([]byte) (int, error)
699 }); ok {
700 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
701 if err != nil {
702 return 0, err
703 }
704 i -= size
705 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
706 } else {
707 encoded, err := proto.Marshal(m.Metadata)
708 if err != nil {
709 return 0, err
710 }
711 i -= len(encoded)
712 copy(dAtA[i:], encoded)
713 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
714 }
715 i--
716 dAtA[i] = 0x3a
717 } else {
718 i = protohelpers.EncodeVarint(dAtA, i, 0)
719 i--
720 dAtA[i] = 0x3a
721 }
722 return len(dAtA) - i, nil
723 }
724 func (m *Permission_NotRule) MarshalToVTStrict(dAtA []byte) (int, error) {
725 size := m.SizeVT()
726 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
727 }
728
729 func (m *Permission_NotRule) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
730 i := len(dAtA)
731 if m.NotRule != nil {
732 size, err := m.NotRule.MarshalToSizedBufferVTStrict(dAtA[:i])
733 if err != nil {
734 return 0, err
735 }
736 i -= size
737 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
738 i--
739 dAtA[i] = 0x42
740 } else {
741 i = protohelpers.EncodeVarint(dAtA, i, 0)
742 i--
743 dAtA[i] = 0x42
744 }
745 return len(dAtA) - i, nil
746 }
747 func (m *Permission_RequestedServerName) MarshalToVTStrict(dAtA []byte) (int, error) {
748 size := m.SizeVT()
749 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
750 }
751
752 func (m *Permission_RequestedServerName) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
753 i := len(dAtA)
754 if m.RequestedServerName != nil {
755 if vtmsg, ok := interface{}(m.RequestedServerName).(interface {
756 MarshalToSizedBufferVTStrict([]byte) (int, error)
757 }); ok {
758 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
759 if err != nil {
760 return 0, err
761 }
762 i -= size
763 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
764 } else {
765 encoded, err := proto.Marshal(m.RequestedServerName)
766 if err != nil {
767 return 0, err
768 }
769 i -= len(encoded)
770 copy(dAtA[i:], encoded)
771 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
772 }
773 i--
774 dAtA[i] = 0x4a
775 } else {
776 i = protohelpers.EncodeVarint(dAtA, i, 0)
777 i--
778 dAtA[i] = 0x4a
779 }
780 return len(dAtA) - i, nil
781 }
782 func (m *Permission_UrlPath) MarshalToVTStrict(dAtA []byte) (int, error) {
783 size := m.SizeVT()
784 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
785 }
786
787 func (m *Permission_UrlPath) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
788 i := len(dAtA)
789 if m.UrlPath != nil {
790 if vtmsg, ok := interface{}(m.UrlPath).(interface {
791 MarshalToSizedBufferVTStrict([]byte) (int, error)
792 }); ok {
793 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
794 if err != nil {
795 return 0, err
796 }
797 i -= size
798 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
799 } else {
800 encoded, err := proto.Marshal(m.UrlPath)
801 if err != nil {
802 return 0, err
803 }
804 i -= len(encoded)
805 copy(dAtA[i:], encoded)
806 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
807 }
808 i--
809 dAtA[i] = 0x52
810 } else {
811 i = protohelpers.EncodeVarint(dAtA, i, 0)
812 i--
813 dAtA[i] = 0x52
814 }
815 return len(dAtA) - i, nil
816 }
817 func (m *Permission_DestinationPortRange) MarshalToVTStrict(dAtA []byte) (int, error) {
818 size := m.SizeVT()
819 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
820 }
821
822 func (m *Permission_DestinationPortRange) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
823 i := len(dAtA)
824 if m.DestinationPortRange != nil {
825 if vtmsg, ok := interface{}(m.DestinationPortRange).(interface {
826 MarshalToSizedBufferVTStrict([]byte) (int, error)
827 }); ok {
828 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
829 if err != nil {
830 return 0, err
831 }
832 i -= size
833 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
834 } else {
835 encoded, err := proto.Marshal(m.DestinationPortRange)
836 if err != nil {
837 return 0, err
838 }
839 i -= len(encoded)
840 copy(dAtA[i:], encoded)
841 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
842 }
843 i--
844 dAtA[i] = 0x5a
845 } else {
846 i = protohelpers.EncodeVarint(dAtA, i, 0)
847 i--
848 dAtA[i] = 0x5a
849 }
850 return len(dAtA) - i, nil
851 }
852 func (m *Permission_Matcher) MarshalToVTStrict(dAtA []byte) (int, error) {
853 size := m.SizeVT()
854 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
855 }
856
857 func (m *Permission_Matcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
858 i := len(dAtA)
859 if m.Matcher != nil {
860 if vtmsg, ok := interface{}(m.Matcher).(interface {
861 MarshalToSizedBufferVTStrict([]byte) (int, error)
862 }); ok {
863 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
864 if err != nil {
865 return 0, err
866 }
867 i -= size
868 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
869 } else {
870 encoded, err := proto.Marshal(m.Matcher)
871 if err != nil {
872 return 0, err
873 }
874 i -= len(encoded)
875 copy(dAtA[i:], encoded)
876 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
877 }
878 i--
879 dAtA[i] = 0x62
880 } else {
881 i = protohelpers.EncodeVarint(dAtA, i, 0)
882 i--
883 dAtA[i] = 0x62
884 }
885 return len(dAtA) - i, nil
886 }
887 func (m *Permission_UriTemplate) MarshalToVTStrict(dAtA []byte) (int, error) {
888 size := m.SizeVT()
889 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
890 }
891
892 func (m *Permission_UriTemplate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
893 i := len(dAtA)
894 if m.UriTemplate != nil {
895 if vtmsg, ok := interface{}(m.UriTemplate).(interface {
896 MarshalToSizedBufferVTStrict([]byte) (int, error)
897 }); ok {
898 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
899 if err != nil {
900 return 0, err
901 }
902 i -= size
903 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
904 } else {
905 encoded, err := proto.Marshal(m.UriTemplate)
906 if err != nil {
907 return 0, err
908 }
909 i -= len(encoded)
910 copy(dAtA[i:], encoded)
911 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
912 }
913 i--
914 dAtA[i] = 0x6a
915 } else {
916 i = protohelpers.EncodeVarint(dAtA, i, 0)
917 i--
918 dAtA[i] = 0x6a
919 }
920 return len(dAtA) - i, nil
921 }
922 func (m *Permission_SourcedMetadata) MarshalToVTStrict(dAtA []byte) (int, error) {
923 size := m.SizeVT()
924 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
925 }
926
927 func (m *Permission_SourcedMetadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
928 i := len(dAtA)
929 if m.SourcedMetadata != nil {
930 size, err := m.SourcedMetadata.MarshalToSizedBufferVTStrict(dAtA[:i])
931 if err != nil {
932 return 0, err
933 }
934 i -= size
935 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
936 i--
937 dAtA[i] = 0x72
938 } else {
939 i = protohelpers.EncodeVarint(dAtA, i, 0)
940 i--
941 dAtA[i] = 0x72
942 }
943 return len(dAtA) - i, nil
944 }
945 func (m *Principal_Set) MarshalVTStrict() (dAtA []byte, err error) {
946 if m == nil {
947 return nil, nil
948 }
949 size := m.SizeVT()
950 dAtA = make([]byte, size)
951 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
952 if err != nil {
953 return nil, err
954 }
955 return dAtA[:n], nil
956 }
957
958 func (m *Principal_Set) MarshalToVTStrict(dAtA []byte) (int, error) {
959 size := m.SizeVT()
960 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
961 }
962
963 func (m *Principal_Set) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
964 if m == nil {
965 return 0, nil
966 }
967 i := len(dAtA)
968 _ = i
969 var l int
970 _ = l
971 if m.unknownFields != nil {
972 i -= len(m.unknownFields)
973 copy(dAtA[i:], m.unknownFields)
974 }
975 if len(m.Ids) > 0 {
976 for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
977 size, err := m.Ids[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
978 if err != nil {
979 return 0, err
980 }
981 i -= size
982 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
983 i--
984 dAtA[i] = 0xa
985 }
986 }
987 return len(dAtA) - i, nil
988 }
989
990 func (m *Principal_Authenticated) MarshalVTStrict() (dAtA []byte, err error) {
991 if m == nil {
992 return nil, nil
993 }
994 size := m.SizeVT()
995 dAtA = make([]byte, size)
996 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
997 if err != nil {
998 return nil, err
999 }
1000 return dAtA[:n], nil
1001 }
1002
1003 func (m *Principal_Authenticated) MarshalToVTStrict(dAtA []byte) (int, error) {
1004 size := m.SizeVT()
1005 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1006 }
1007
1008 func (m *Principal_Authenticated) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1009 if m == nil {
1010 return 0, nil
1011 }
1012 i := len(dAtA)
1013 _ = i
1014 var l int
1015 _ = l
1016 if m.unknownFields != nil {
1017 i -= len(m.unknownFields)
1018 copy(dAtA[i:], m.unknownFields)
1019 }
1020 if m.PrincipalName != nil {
1021 if vtmsg, ok := interface{}(m.PrincipalName).(interface {
1022 MarshalToSizedBufferVTStrict([]byte) (int, error)
1023 }); ok {
1024 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1025 if err != nil {
1026 return 0, err
1027 }
1028 i -= size
1029 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1030 } else {
1031 encoded, err := proto.Marshal(m.PrincipalName)
1032 if err != nil {
1033 return 0, err
1034 }
1035 i -= len(encoded)
1036 copy(dAtA[i:], encoded)
1037 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1038 }
1039 i--
1040 dAtA[i] = 0x12
1041 }
1042 return len(dAtA) - i, nil
1043 }
1044
1045 func (m *Principal) MarshalVTStrict() (dAtA []byte, err error) {
1046 if m == nil {
1047 return nil, nil
1048 }
1049 size := m.SizeVT()
1050 dAtA = make([]byte, size)
1051 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1052 if err != nil {
1053 return nil, err
1054 }
1055 return dAtA[:n], nil
1056 }
1057
1058 func (m *Principal) MarshalToVTStrict(dAtA []byte) (int, error) {
1059 size := m.SizeVT()
1060 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1061 }
1062
1063 func (m *Principal) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1064 if m == nil {
1065 return 0, nil
1066 }
1067 i := len(dAtA)
1068 _ = i
1069 var l int
1070 _ = l
1071 if m.unknownFields != nil {
1072 i -= len(m.unknownFields)
1073 copy(dAtA[i:], m.unknownFields)
1074 }
1075 if msg, ok := m.Identifier.(*Principal_SourcedMetadata); ok {
1076 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1077 if err != nil {
1078 return 0, err
1079 }
1080 i -= size
1081 }
1082 if msg, ok := m.Identifier.(*Principal_FilterState); ok {
1083 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1084 if err != nil {
1085 return 0, err
1086 }
1087 i -= size
1088 }
1089 if msg, ok := m.Identifier.(*Principal_RemoteIp); ok {
1090 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1091 if err != nil {
1092 return 0, err
1093 }
1094 i -= size
1095 }
1096 if msg, ok := m.Identifier.(*Principal_DirectRemoteIp); ok {
1097 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1098 if err != nil {
1099 return 0, err
1100 }
1101 i -= size
1102 }
1103 if msg, ok := m.Identifier.(*Principal_UrlPath); ok {
1104 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1105 if err != nil {
1106 return 0, err
1107 }
1108 i -= size
1109 }
1110 if msg, ok := m.Identifier.(*Principal_NotId); ok {
1111 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1112 if err != nil {
1113 return 0, err
1114 }
1115 i -= size
1116 }
1117 if msg, ok := m.Identifier.(*Principal_Metadata); ok {
1118 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1119 if err != nil {
1120 return 0, err
1121 }
1122 i -= size
1123 }
1124 if msg, ok := m.Identifier.(*Principal_Header); ok {
1125 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1126 if err != nil {
1127 return 0, err
1128 }
1129 i -= size
1130 }
1131 if msg, ok := m.Identifier.(*Principal_SourceIp); ok {
1132 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1133 if err != nil {
1134 return 0, err
1135 }
1136 i -= size
1137 }
1138 if msg, ok := m.Identifier.(*Principal_Authenticated_); ok {
1139 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1140 if err != nil {
1141 return 0, err
1142 }
1143 i -= size
1144 }
1145 if msg, ok := m.Identifier.(*Principal_Any); ok {
1146 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1147 if err != nil {
1148 return 0, err
1149 }
1150 i -= size
1151 }
1152 if msg, ok := m.Identifier.(*Principal_OrIds); ok {
1153 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1154 if err != nil {
1155 return 0, err
1156 }
1157 i -= size
1158 }
1159 if msg, ok := m.Identifier.(*Principal_AndIds); ok {
1160 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1161 if err != nil {
1162 return 0, err
1163 }
1164 i -= size
1165 }
1166 return len(dAtA) - i, nil
1167 }
1168
1169 func (m *Principal_AndIds) MarshalToVTStrict(dAtA []byte) (int, error) {
1170 size := m.SizeVT()
1171 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1172 }
1173
1174 func (m *Principal_AndIds) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1175 i := len(dAtA)
1176 if m.AndIds != nil {
1177 size, err := m.AndIds.MarshalToSizedBufferVTStrict(dAtA[:i])
1178 if err != nil {
1179 return 0, err
1180 }
1181 i -= size
1182 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1183 i--
1184 dAtA[i] = 0xa
1185 } else {
1186 i = protohelpers.EncodeVarint(dAtA, i, 0)
1187 i--
1188 dAtA[i] = 0xa
1189 }
1190 return len(dAtA) - i, nil
1191 }
1192 func (m *Principal_OrIds) MarshalToVTStrict(dAtA []byte) (int, error) {
1193 size := m.SizeVT()
1194 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1195 }
1196
1197 func (m *Principal_OrIds) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1198 i := len(dAtA)
1199 if m.OrIds != nil {
1200 size, err := m.OrIds.MarshalToSizedBufferVTStrict(dAtA[:i])
1201 if err != nil {
1202 return 0, err
1203 }
1204 i -= size
1205 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1206 i--
1207 dAtA[i] = 0x12
1208 } else {
1209 i = protohelpers.EncodeVarint(dAtA, i, 0)
1210 i--
1211 dAtA[i] = 0x12
1212 }
1213 return len(dAtA) - i, nil
1214 }
1215 func (m *Principal_Any) MarshalToVTStrict(dAtA []byte) (int, error) {
1216 size := m.SizeVT()
1217 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1218 }
1219
1220 func (m *Principal_Any) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1221 i := len(dAtA)
1222 i--
1223 if m.Any {
1224 dAtA[i] = 1
1225 } else {
1226 dAtA[i] = 0
1227 }
1228 i--
1229 dAtA[i] = 0x18
1230 return len(dAtA) - i, nil
1231 }
1232 func (m *Principal_Authenticated_) MarshalToVTStrict(dAtA []byte) (int, error) {
1233 size := m.SizeVT()
1234 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1235 }
1236
1237 func (m *Principal_Authenticated_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1238 i := len(dAtA)
1239 if m.Authenticated != nil {
1240 size, err := m.Authenticated.MarshalToSizedBufferVTStrict(dAtA[:i])
1241 if err != nil {
1242 return 0, err
1243 }
1244 i -= size
1245 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1246 i--
1247 dAtA[i] = 0x22
1248 } else {
1249 i = protohelpers.EncodeVarint(dAtA, i, 0)
1250 i--
1251 dAtA[i] = 0x22
1252 }
1253 return len(dAtA) - i, nil
1254 }
1255 func (m *Principal_SourceIp) MarshalToVTStrict(dAtA []byte) (int, error) {
1256 size := m.SizeVT()
1257 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1258 }
1259
1260 func (m *Principal_SourceIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1261 i := len(dAtA)
1262 if m.SourceIp != nil {
1263 if vtmsg, ok := interface{}(m.SourceIp).(interface {
1264 MarshalToSizedBufferVTStrict([]byte) (int, error)
1265 }); ok {
1266 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1267 if err != nil {
1268 return 0, err
1269 }
1270 i -= size
1271 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1272 } else {
1273 encoded, err := proto.Marshal(m.SourceIp)
1274 if err != nil {
1275 return 0, err
1276 }
1277 i -= len(encoded)
1278 copy(dAtA[i:], encoded)
1279 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1280 }
1281 i--
1282 dAtA[i] = 0x2a
1283 } else {
1284 i = protohelpers.EncodeVarint(dAtA, i, 0)
1285 i--
1286 dAtA[i] = 0x2a
1287 }
1288 return len(dAtA) - i, nil
1289 }
1290 func (m *Principal_Header) MarshalToVTStrict(dAtA []byte) (int, error) {
1291 size := m.SizeVT()
1292 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1293 }
1294
1295 func (m *Principal_Header) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1296 i := len(dAtA)
1297 if m.Header != nil {
1298 if vtmsg, ok := interface{}(m.Header).(interface {
1299 MarshalToSizedBufferVTStrict([]byte) (int, error)
1300 }); ok {
1301 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1302 if err != nil {
1303 return 0, err
1304 }
1305 i -= size
1306 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1307 } else {
1308 encoded, err := proto.Marshal(m.Header)
1309 if err != nil {
1310 return 0, err
1311 }
1312 i -= len(encoded)
1313 copy(dAtA[i:], encoded)
1314 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1315 }
1316 i--
1317 dAtA[i] = 0x32
1318 } else {
1319 i = protohelpers.EncodeVarint(dAtA, i, 0)
1320 i--
1321 dAtA[i] = 0x32
1322 }
1323 return len(dAtA) - i, nil
1324 }
1325 func (m *Principal_Metadata) MarshalToVTStrict(dAtA []byte) (int, error) {
1326 size := m.SizeVT()
1327 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1328 }
1329
1330 func (m *Principal_Metadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1331 i := len(dAtA)
1332 if m.Metadata != nil {
1333 if vtmsg, ok := interface{}(m.Metadata).(interface {
1334 MarshalToSizedBufferVTStrict([]byte) (int, error)
1335 }); ok {
1336 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1337 if err != nil {
1338 return 0, err
1339 }
1340 i -= size
1341 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1342 } else {
1343 encoded, err := proto.Marshal(m.Metadata)
1344 if err != nil {
1345 return 0, err
1346 }
1347 i -= len(encoded)
1348 copy(dAtA[i:], encoded)
1349 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1350 }
1351 i--
1352 dAtA[i] = 0x3a
1353 } else {
1354 i = protohelpers.EncodeVarint(dAtA, i, 0)
1355 i--
1356 dAtA[i] = 0x3a
1357 }
1358 return len(dAtA) - i, nil
1359 }
1360 func (m *Principal_NotId) MarshalToVTStrict(dAtA []byte) (int, error) {
1361 size := m.SizeVT()
1362 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1363 }
1364
1365 func (m *Principal_NotId) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1366 i := len(dAtA)
1367 if m.NotId != nil {
1368 size, err := m.NotId.MarshalToSizedBufferVTStrict(dAtA[:i])
1369 if err != nil {
1370 return 0, err
1371 }
1372 i -= size
1373 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1374 i--
1375 dAtA[i] = 0x42
1376 } else {
1377 i = protohelpers.EncodeVarint(dAtA, i, 0)
1378 i--
1379 dAtA[i] = 0x42
1380 }
1381 return len(dAtA) - i, nil
1382 }
1383 func (m *Principal_UrlPath) MarshalToVTStrict(dAtA []byte) (int, error) {
1384 size := m.SizeVT()
1385 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1386 }
1387
1388 func (m *Principal_UrlPath) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1389 i := len(dAtA)
1390 if m.UrlPath != nil {
1391 if vtmsg, ok := interface{}(m.UrlPath).(interface {
1392 MarshalToSizedBufferVTStrict([]byte) (int, error)
1393 }); ok {
1394 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1395 if err != nil {
1396 return 0, err
1397 }
1398 i -= size
1399 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1400 } else {
1401 encoded, err := proto.Marshal(m.UrlPath)
1402 if err != nil {
1403 return 0, err
1404 }
1405 i -= len(encoded)
1406 copy(dAtA[i:], encoded)
1407 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1408 }
1409 i--
1410 dAtA[i] = 0x4a
1411 } else {
1412 i = protohelpers.EncodeVarint(dAtA, i, 0)
1413 i--
1414 dAtA[i] = 0x4a
1415 }
1416 return len(dAtA) - i, nil
1417 }
1418 func (m *Principal_DirectRemoteIp) MarshalToVTStrict(dAtA []byte) (int, error) {
1419 size := m.SizeVT()
1420 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1421 }
1422
1423 func (m *Principal_DirectRemoteIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1424 i := len(dAtA)
1425 if m.DirectRemoteIp != nil {
1426 if vtmsg, ok := interface{}(m.DirectRemoteIp).(interface {
1427 MarshalToSizedBufferVTStrict([]byte) (int, error)
1428 }); ok {
1429 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1430 if err != nil {
1431 return 0, err
1432 }
1433 i -= size
1434 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1435 } else {
1436 encoded, err := proto.Marshal(m.DirectRemoteIp)
1437 if err != nil {
1438 return 0, err
1439 }
1440 i -= len(encoded)
1441 copy(dAtA[i:], encoded)
1442 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1443 }
1444 i--
1445 dAtA[i] = 0x52
1446 } else {
1447 i = protohelpers.EncodeVarint(dAtA, i, 0)
1448 i--
1449 dAtA[i] = 0x52
1450 }
1451 return len(dAtA) - i, nil
1452 }
1453 func (m *Principal_RemoteIp) MarshalToVTStrict(dAtA []byte) (int, error) {
1454 size := m.SizeVT()
1455 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1456 }
1457
1458 func (m *Principal_RemoteIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1459 i := len(dAtA)
1460 if m.RemoteIp != nil {
1461 if vtmsg, ok := interface{}(m.RemoteIp).(interface {
1462 MarshalToSizedBufferVTStrict([]byte) (int, error)
1463 }); ok {
1464 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1465 if err != nil {
1466 return 0, err
1467 }
1468 i -= size
1469 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1470 } else {
1471 encoded, err := proto.Marshal(m.RemoteIp)
1472 if err != nil {
1473 return 0, err
1474 }
1475 i -= len(encoded)
1476 copy(dAtA[i:], encoded)
1477 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1478 }
1479 i--
1480 dAtA[i] = 0x5a
1481 } else {
1482 i = protohelpers.EncodeVarint(dAtA, i, 0)
1483 i--
1484 dAtA[i] = 0x5a
1485 }
1486 return len(dAtA) - i, nil
1487 }
1488 func (m *Principal_FilterState) MarshalToVTStrict(dAtA []byte) (int, error) {
1489 size := m.SizeVT()
1490 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1491 }
1492
1493 func (m *Principal_FilterState) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1494 i := len(dAtA)
1495 if m.FilterState != nil {
1496 if vtmsg, ok := interface{}(m.FilterState).(interface {
1497 MarshalToSizedBufferVTStrict([]byte) (int, error)
1498 }); ok {
1499 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1500 if err != nil {
1501 return 0, err
1502 }
1503 i -= size
1504 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1505 } else {
1506 encoded, err := proto.Marshal(m.FilterState)
1507 if err != nil {
1508 return 0, err
1509 }
1510 i -= len(encoded)
1511 copy(dAtA[i:], encoded)
1512 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1513 }
1514 i--
1515 dAtA[i] = 0x62
1516 } else {
1517 i = protohelpers.EncodeVarint(dAtA, i, 0)
1518 i--
1519 dAtA[i] = 0x62
1520 }
1521 return len(dAtA) - i, nil
1522 }
1523 func (m *Principal_SourcedMetadata) MarshalToVTStrict(dAtA []byte) (int, error) {
1524 size := m.SizeVT()
1525 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1526 }
1527
1528 func (m *Principal_SourcedMetadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1529 i := len(dAtA)
1530 if m.SourcedMetadata != nil {
1531 size, err := m.SourcedMetadata.MarshalToSizedBufferVTStrict(dAtA[:i])
1532 if err != nil {
1533 return 0, err
1534 }
1535 i -= size
1536 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1537 i--
1538 dAtA[i] = 0x6a
1539 } else {
1540 i = protohelpers.EncodeVarint(dAtA, i, 0)
1541 i--
1542 dAtA[i] = 0x6a
1543 }
1544 return len(dAtA) - i, nil
1545 }
1546 func (m *Action) MarshalVTStrict() (dAtA []byte, err error) {
1547 if m == nil {
1548 return nil, nil
1549 }
1550 size := m.SizeVT()
1551 dAtA = make([]byte, size)
1552 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1553 if err != nil {
1554 return nil, err
1555 }
1556 return dAtA[:n], nil
1557 }
1558
1559 func (m *Action) MarshalToVTStrict(dAtA []byte) (int, error) {
1560 size := m.SizeVT()
1561 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1562 }
1563
1564 func (m *Action) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1565 if m == nil {
1566 return 0, nil
1567 }
1568 i := len(dAtA)
1569 _ = i
1570 var l int
1571 _ = l
1572 if m.unknownFields != nil {
1573 i -= len(m.unknownFields)
1574 copy(dAtA[i:], m.unknownFields)
1575 }
1576 if m.Action != 0 {
1577 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Action))
1578 i--
1579 dAtA[i] = 0x10
1580 }
1581 if len(m.Name) > 0 {
1582 i -= len(m.Name)
1583 copy(dAtA[i:], m.Name)
1584 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1585 i--
1586 dAtA[i] = 0xa
1587 }
1588 return len(dAtA) - i, nil
1589 }
1590
1591 func (m *RBAC_AuditLoggingOptions_AuditLoggerConfig) SizeVT() (n int) {
1592 if m == nil {
1593 return 0
1594 }
1595 var l int
1596 _ = l
1597 if m.AuditLogger != nil {
1598 if size, ok := interface{}(m.AuditLogger).(interface {
1599 SizeVT() int
1600 }); ok {
1601 l = size.SizeVT()
1602 } else {
1603 l = proto.Size(m.AuditLogger)
1604 }
1605 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1606 }
1607 if m.IsOptional {
1608 n += 2
1609 }
1610 n += len(m.unknownFields)
1611 return n
1612 }
1613
1614 func (m *RBAC_AuditLoggingOptions) SizeVT() (n int) {
1615 if m == nil {
1616 return 0
1617 }
1618 var l int
1619 _ = l
1620 if m.AuditCondition != 0 {
1621 n += 1 + protohelpers.SizeOfVarint(uint64(m.AuditCondition))
1622 }
1623 if len(m.LoggerConfigs) > 0 {
1624 for _, e := range m.LoggerConfigs {
1625 l = e.SizeVT()
1626 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1627 }
1628 }
1629 n += len(m.unknownFields)
1630 return n
1631 }
1632
1633 func (m *RBAC) SizeVT() (n int) {
1634 if m == nil {
1635 return 0
1636 }
1637 var l int
1638 _ = l
1639 if m.Action != 0 {
1640 n += 1 + protohelpers.SizeOfVarint(uint64(m.Action))
1641 }
1642 if len(m.Policies) > 0 {
1643 for k, v := range m.Policies {
1644 _ = k
1645 _ = v
1646 l = 0
1647 if v != nil {
1648 l = v.SizeVT()
1649 }
1650 l += 1 + protohelpers.SizeOfVarint(uint64(l))
1651 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
1652 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
1653 }
1654 }
1655 if m.AuditLoggingOptions != nil {
1656 l = m.AuditLoggingOptions.SizeVT()
1657 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1658 }
1659 n += len(m.unknownFields)
1660 return n
1661 }
1662
1663 func (m *Policy) SizeVT() (n int) {
1664 if m == nil {
1665 return 0
1666 }
1667 var l int
1668 _ = l
1669 if len(m.Permissions) > 0 {
1670 for _, e := range m.Permissions {
1671 l = e.SizeVT()
1672 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1673 }
1674 }
1675 if len(m.Principals) > 0 {
1676 for _, e := range m.Principals {
1677 l = e.SizeVT()
1678 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1679 }
1680 }
1681 if m.Condition != nil {
1682 if size, ok := interface{}(m.Condition).(interface {
1683 SizeVT() int
1684 }); ok {
1685 l = size.SizeVT()
1686 } else {
1687 l = proto.Size(m.Condition)
1688 }
1689 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1690 }
1691 if m.CheckedCondition != nil {
1692 if size, ok := interface{}(m.CheckedCondition).(interface {
1693 SizeVT() int
1694 }); ok {
1695 l = size.SizeVT()
1696 } else {
1697 l = proto.Size(m.CheckedCondition)
1698 }
1699 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1700 }
1701 n += len(m.unknownFields)
1702 return n
1703 }
1704
1705 func (m *SourcedMetadata) SizeVT() (n int) {
1706 if m == nil {
1707 return 0
1708 }
1709 var l int
1710 _ = l
1711 if m.MetadataMatcher != nil {
1712 if size, ok := interface{}(m.MetadataMatcher).(interface {
1713 SizeVT() int
1714 }); ok {
1715 l = size.SizeVT()
1716 } else {
1717 l = proto.Size(m.MetadataMatcher)
1718 }
1719 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1720 }
1721 if m.MetadataSource != 0 {
1722 n += 1 + protohelpers.SizeOfVarint(uint64(m.MetadataSource))
1723 }
1724 n += len(m.unknownFields)
1725 return n
1726 }
1727
1728 func (m *Permission_Set) SizeVT() (n int) {
1729 if m == nil {
1730 return 0
1731 }
1732 var l int
1733 _ = l
1734 if len(m.Rules) > 0 {
1735 for _, e := range m.Rules {
1736 l = e.SizeVT()
1737 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1738 }
1739 }
1740 n += len(m.unknownFields)
1741 return n
1742 }
1743
1744 func (m *Permission) SizeVT() (n int) {
1745 if m == nil {
1746 return 0
1747 }
1748 var l int
1749 _ = l
1750 if vtmsg, ok := m.Rule.(interface{ SizeVT() int }); ok {
1751 n += vtmsg.SizeVT()
1752 }
1753 n += len(m.unknownFields)
1754 return n
1755 }
1756
1757 func (m *Permission_AndRules) SizeVT() (n int) {
1758 if m == nil {
1759 return 0
1760 }
1761 var l int
1762 _ = l
1763 if m.AndRules != nil {
1764 l = m.AndRules.SizeVT()
1765 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1766 } else {
1767 n += 2
1768 }
1769 return n
1770 }
1771 func (m *Permission_OrRules) SizeVT() (n int) {
1772 if m == nil {
1773 return 0
1774 }
1775 var l int
1776 _ = l
1777 if m.OrRules != nil {
1778 l = m.OrRules.SizeVT()
1779 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1780 } else {
1781 n += 2
1782 }
1783 return n
1784 }
1785 func (m *Permission_Any) SizeVT() (n int) {
1786 if m == nil {
1787 return 0
1788 }
1789 var l int
1790 _ = l
1791 n += 2
1792 return n
1793 }
1794 func (m *Permission_Header) SizeVT() (n int) {
1795 if m == nil {
1796 return 0
1797 }
1798 var l int
1799 _ = l
1800 if m.Header != nil {
1801 if size, ok := interface{}(m.Header).(interface {
1802 SizeVT() int
1803 }); ok {
1804 l = size.SizeVT()
1805 } else {
1806 l = proto.Size(m.Header)
1807 }
1808 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1809 } else {
1810 n += 2
1811 }
1812 return n
1813 }
1814 func (m *Permission_DestinationIp) SizeVT() (n int) {
1815 if m == nil {
1816 return 0
1817 }
1818 var l int
1819 _ = l
1820 if m.DestinationIp != nil {
1821 if size, ok := interface{}(m.DestinationIp).(interface {
1822 SizeVT() int
1823 }); ok {
1824 l = size.SizeVT()
1825 } else {
1826 l = proto.Size(m.DestinationIp)
1827 }
1828 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1829 } else {
1830 n += 2
1831 }
1832 return n
1833 }
1834 func (m *Permission_DestinationPort) SizeVT() (n int) {
1835 if m == nil {
1836 return 0
1837 }
1838 var l int
1839 _ = l
1840 n += 1 + protohelpers.SizeOfVarint(uint64(m.DestinationPort))
1841 return n
1842 }
1843 func (m *Permission_Metadata) SizeVT() (n int) {
1844 if m == nil {
1845 return 0
1846 }
1847 var l int
1848 _ = l
1849 if m.Metadata != nil {
1850 if size, ok := interface{}(m.Metadata).(interface {
1851 SizeVT() int
1852 }); ok {
1853 l = size.SizeVT()
1854 } else {
1855 l = proto.Size(m.Metadata)
1856 }
1857 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1858 } else {
1859 n += 2
1860 }
1861 return n
1862 }
1863 func (m *Permission_NotRule) SizeVT() (n int) {
1864 if m == nil {
1865 return 0
1866 }
1867 var l int
1868 _ = l
1869 if m.NotRule != nil {
1870 l = m.NotRule.SizeVT()
1871 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1872 } else {
1873 n += 2
1874 }
1875 return n
1876 }
1877 func (m *Permission_RequestedServerName) SizeVT() (n int) {
1878 if m == nil {
1879 return 0
1880 }
1881 var l int
1882 _ = l
1883 if m.RequestedServerName != nil {
1884 if size, ok := interface{}(m.RequestedServerName).(interface {
1885 SizeVT() int
1886 }); ok {
1887 l = size.SizeVT()
1888 } else {
1889 l = proto.Size(m.RequestedServerName)
1890 }
1891 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1892 } else {
1893 n += 2
1894 }
1895 return n
1896 }
1897 func (m *Permission_UrlPath) SizeVT() (n int) {
1898 if m == nil {
1899 return 0
1900 }
1901 var l int
1902 _ = l
1903 if m.UrlPath != nil {
1904 if size, ok := interface{}(m.UrlPath).(interface {
1905 SizeVT() int
1906 }); ok {
1907 l = size.SizeVT()
1908 } else {
1909 l = proto.Size(m.UrlPath)
1910 }
1911 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1912 } else {
1913 n += 2
1914 }
1915 return n
1916 }
1917 func (m *Permission_DestinationPortRange) SizeVT() (n int) {
1918 if m == nil {
1919 return 0
1920 }
1921 var l int
1922 _ = l
1923 if m.DestinationPortRange != nil {
1924 if size, ok := interface{}(m.DestinationPortRange).(interface {
1925 SizeVT() int
1926 }); ok {
1927 l = size.SizeVT()
1928 } else {
1929 l = proto.Size(m.DestinationPortRange)
1930 }
1931 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1932 } else {
1933 n += 2
1934 }
1935 return n
1936 }
1937 func (m *Permission_Matcher) SizeVT() (n int) {
1938 if m == nil {
1939 return 0
1940 }
1941 var l int
1942 _ = l
1943 if m.Matcher != nil {
1944 if size, ok := interface{}(m.Matcher).(interface {
1945 SizeVT() int
1946 }); ok {
1947 l = size.SizeVT()
1948 } else {
1949 l = proto.Size(m.Matcher)
1950 }
1951 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1952 } else {
1953 n += 2
1954 }
1955 return n
1956 }
1957 func (m *Permission_UriTemplate) SizeVT() (n int) {
1958 if m == nil {
1959 return 0
1960 }
1961 var l int
1962 _ = l
1963 if m.UriTemplate != nil {
1964 if size, ok := interface{}(m.UriTemplate).(interface {
1965 SizeVT() int
1966 }); ok {
1967 l = size.SizeVT()
1968 } else {
1969 l = proto.Size(m.UriTemplate)
1970 }
1971 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1972 } else {
1973 n += 2
1974 }
1975 return n
1976 }
1977 func (m *Permission_SourcedMetadata) SizeVT() (n int) {
1978 if m == nil {
1979 return 0
1980 }
1981 var l int
1982 _ = l
1983 if m.SourcedMetadata != nil {
1984 l = m.SourcedMetadata.SizeVT()
1985 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1986 } else {
1987 n += 2
1988 }
1989 return n
1990 }
1991 func (m *Principal_Set) SizeVT() (n int) {
1992 if m == nil {
1993 return 0
1994 }
1995 var l int
1996 _ = l
1997 if len(m.Ids) > 0 {
1998 for _, e := range m.Ids {
1999 l = e.SizeVT()
2000 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2001 }
2002 }
2003 n += len(m.unknownFields)
2004 return n
2005 }
2006
2007 func (m *Principal_Authenticated) SizeVT() (n int) {
2008 if m == nil {
2009 return 0
2010 }
2011 var l int
2012 _ = l
2013 if m.PrincipalName != nil {
2014 if size, ok := interface{}(m.PrincipalName).(interface {
2015 SizeVT() int
2016 }); ok {
2017 l = size.SizeVT()
2018 } else {
2019 l = proto.Size(m.PrincipalName)
2020 }
2021 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2022 }
2023 n += len(m.unknownFields)
2024 return n
2025 }
2026
2027 func (m *Principal) SizeVT() (n int) {
2028 if m == nil {
2029 return 0
2030 }
2031 var l int
2032 _ = l
2033 if vtmsg, ok := m.Identifier.(interface{ SizeVT() int }); ok {
2034 n += vtmsg.SizeVT()
2035 }
2036 n += len(m.unknownFields)
2037 return n
2038 }
2039
2040 func (m *Principal_AndIds) SizeVT() (n int) {
2041 if m == nil {
2042 return 0
2043 }
2044 var l int
2045 _ = l
2046 if m.AndIds != nil {
2047 l = m.AndIds.SizeVT()
2048 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2049 } else {
2050 n += 2
2051 }
2052 return n
2053 }
2054 func (m *Principal_OrIds) SizeVT() (n int) {
2055 if m == nil {
2056 return 0
2057 }
2058 var l int
2059 _ = l
2060 if m.OrIds != nil {
2061 l = m.OrIds.SizeVT()
2062 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2063 } else {
2064 n += 2
2065 }
2066 return n
2067 }
2068 func (m *Principal_Any) SizeVT() (n int) {
2069 if m == nil {
2070 return 0
2071 }
2072 var l int
2073 _ = l
2074 n += 2
2075 return n
2076 }
2077 func (m *Principal_Authenticated_) SizeVT() (n int) {
2078 if m == nil {
2079 return 0
2080 }
2081 var l int
2082 _ = l
2083 if m.Authenticated != nil {
2084 l = m.Authenticated.SizeVT()
2085 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2086 } else {
2087 n += 2
2088 }
2089 return n
2090 }
2091 func (m *Principal_SourceIp) SizeVT() (n int) {
2092 if m == nil {
2093 return 0
2094 }
2095 var l int
2096 _ = l
2097 if m.SourceIp != nil {
2098 if size, ok := interface{}(m.SourceIp).(interface {
2099 SizeVT() int
2100 }); ok {
2101 l = size.SizeVT()
2102 } else {
2103 l = proto.Size(m.SourceIp)
2104 }
2105 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2106 } else {
2107 n += 2
2108 }
2109 return n
2110 }
2111 func (m *Principal_Header) SizeVT() (n int) {
2112 if m == nil {
2113 return 0
2114 }
2115 var l int
2116 _ = l
2117 if m.Header != nil {
2118 if size, ok := interface{}(m.Header).(interface {
2119 SizeVT() int
2120 }); ok {
2121 l = size.SizeVT()
2122 } else {
2123 l = proto.Size(m.Header)
2124 }
2125 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2126 } else {
2127 n += 2
2128 }
2129 return n
2130 }
2131 func (m *Principal_Metadata) SizeVT() (n int) {
2132 if m == nil {
2133 return 0
2134 }
2135 var l int
2136 _ = l
2137 if m.Metadata != nil {
2138 if size, ok := interface{}(m.Metadata).(interface {
2139 SizeVT() int
2140 }); ok {
2141 l = size.SizeVT()
2142 } else {
2143 l = proto.Size(m.Metadata)
2144 }
2145 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2146 } else {
2147 n += 2
2148 }
2149 return n
2150 }
2151 func (m *Principal_NotId) SizeVT() (n int) {
2152 if m == nil {
2153 return 0
2154 }
2155 var l int
2156 _ = l
2157 if m.NotId != nil {
2158 l = m.NotId.SizeVT()
2159 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2160 } else {
2161 n += 2
2162 }
2163 return n
2164 }
2165 func (m *Principal_UrlPath) SizeVT() (n int) {
2166 if m == nil {
2167 return 0
2168 }
2169 var l int
2170 _ = l
2171 if m.UrlPath != nil {
2172 if size, ok := interface{}(m.UrlPath).(interface {
2173 SizeVT() int
2174 }); ok {
2175 l = size.SizeVT()
2176 } else {
2177 l = proto.Size(m.UrlPath)
2178 }
2179 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2180 } else {
2181 n += 2
2182 }
2183 return n
2184 }
2185 func (m *Principal_DirectRemoteIp) SizeVT() (n int) {
2186 if m == nil {
2187 return 0
2188 }
2189 var l int
2190 _ = l
2191 if m.DirectRemoteIp != nil {
2192 if size, ok := interface{}(m.DirectRemoteIp).(interface {
2193 SizeVT() int
2194 }); ok {
2195 l = size.SizeVT()
2196 } else {
2197 l = proto.Size(m.DirectRemoteIp)
2198 }
2199 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2200 } else {
2201 n += 2
2202 }
2203 return n
2204 }
2205 func (m *Principal_RemoteIp) SizeVT() (n int) {
2206 if m == nil {
2207 return 0
2208 }
2209 var l int
2210 _ = l
2211 if m.RemoteIp != nil {
2212 if size, ok := interface{}(m.RemoteIp).(interface {
2213 SizeVT() int
2214 }); ok {
2215 l = size.SizeVT()
2216 } else {
2217 l = proto.Size(m.RemoteIp)
2218 }
2219 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2220 } else {
2221 n += 2
2222 }
2223 return n
2224 }
2225 func (m *Principal_FilterState) SizeVT() (n int) {
2226 if m == nil {
2227 return 0
2228 }
2229 var l int
2230 _ = l
2231 if m.FilterState != nil {
2232 if size, ok := interface{}(m.FilterState).(interface {
2233 SizeVT() int
2234 }); ok {
2235 l = size.SizeVT()
2236 } else {
2237 l = proto.Size(m.FilterState)
2238 }
2239 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2240 } else {
2241 n += 2
2242 }
2243 return n
2244 }
2245 func (m *Principal_SourcedMetadata) SizeVT() (n int) {
2246 if m == nil {
2247 return 0
2248 }
2249 var l int
2250 _ = l
2251 if m.SourcedMetadata != nil {
2252 l = m.SourcedMetadata.SizeVT()
2253 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2254 } else {
2255 n += 2
2256 }
2257 return n
2258 }
2259 func (m *Action) SizeVT() (n int) {
2260 if m == nil {
2261 return 0
2262 }
2263 var l int
2264 _ = l
2265 l = len(m.Name)
2266 if l > 0 {
2267 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2268 }
2269 if m.Action != 0 {
2270 n += 1 + protohelpers.SizeOfVarint(uint64(m.Action))
2271 }
2272 n += len(m.unknownFields)
2273 return n
2274 }