Debian Codegraph @

envoy/config/rbac/v2/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/v2/rbac.proto
6
7 package rbacv2
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) 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) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *RBAC) 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 len(m.Policies) > 0 {
53 for k := range m.Policies {
54 v := m.Policies[k]
55 baseI := i
56 size, err := v.MarshalToSizedBufferVTStrict(dAtA[:i])
57 if err != nil {
58 return 0, err
59 }
60 i -= size
61 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
62 i--
63 dAtA[i] = 0x12
64 i -= len(k)
65 copy(dAtA[i:], k)
66 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
67 i--
68 dAtA[i] = 0xa
69 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
70 i--
71 dAtA[i] = 0x12
72 }
73 }
74 if m.Action != 0 {
75 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Action))
76 i--
77 dAtA[i] = 0x8
78 }
79 return len(dAtA) - i, nil
80 }
81
82 func (m *Policy) MarshalVTStrict() (dAtA []byte, err error) {
83 if m == nil {
84 return nil, nil
85 }
86 size := m.SizeVT()
87 dAtA = make([]byte, size)
88 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
89 if err != nil {
90 return nil, err
91 }
92 return dAtA[:n], nil
93 }
94
95 func (m *Policy) MarshalToVTStrict(dAtA []byte) (int, error) {
96 size := m.SizeVT()
97 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
98 }
99
100 func (m *Policy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
101 if m == nil {
102 return 0, nil
103 }
104 i := len(dAtA)
105 _ = i
106 var l int
107 _ = l
108 if m.unknownFields != nil {
109 i -= len(m.unknownFields)
110 copy(dAtA[i:], m.unknownFields)
111 }
112 if m.Condition != nil {
113 if vtmsg, ok := interface{}(m.Condition).(interface {
114 MarshalToSizedBufferVTStrict([]byte) (int, error)
115 }); ok {
116 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
117 if err != nil {
118 return 0, err
119 }
120 i -= size
121 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
122 } else {
123 encoded, err := proto.Marshal(m.Condition)
124 if err != nil {
125 return 0, err
126 }
127 i -= len(encoded)
128 copy(dAtA[i:], encoded)
129 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
130 }
131 i--
132 dAtA[i] = 0x1a
133 }
134 if len(m.Principals) > 0 {
135 for iNdEx := len(m.Principals) - 1; iNdEx >= 0; iNdEx-- {
136 size, err := m.Principals[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
137 if err != nil {
138 return 0, err
139 }
140 i -= size
141 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
142 i--
143 dAtA[i] = 0x12
144 }
145 }
146 if len(m.Permissions) > 0 {
147 for iNdEx := len(m.Permissions) - 1; iNdEx >= 0; iNdEx-- {
148 size, err := m.Permissions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
149 if err != nil {
150 return 0, err
151 }
152 i -= size
153 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
154 i--
155 dAtA[i] = 0xa
156 }
157 }
158 return len(dAtA) - i, nil
159 }
160
161 func (m *Permission_Set) MarshalVTStrict() (dAtA []byte, err error) {
162 if m == nil {
163 return nil, nil
164 }
165 size := m.SizeVT()
166 dAtA = make([]byte, size)
167 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
168 if err != nil {
169 return nil, err
170 }
171 return dAtA[:n], nil
172 }
173
174 func (m *Permission_Set) MarshalToVTStrict(dAtA []byte) (int, error) {
175 size := m.SizeVT()
176 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
177 }
178
179 func (m *Permission_Set) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
180 if m == nil {
181 return 0, nil
182 }
183 i := len(dAtA)
184 _ = i
185 var l int
186 _ = l
187 if m.unknownFields != nil {
188 i -= len(m.unknownFields)
189 copy(dAtA[i:], m.unknownFields)
190 }
191 if len(m.Rules) > 0 {
192 for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
193 size, err := m.Rules[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
194 if err != nil {
195 return 0, err
196 }
197 i -= size
198 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
199 i--
200 dAtA[i] = 0xa
201 }
202 }
203 return len(dAtA) - i, nil
204 }
205
206 func (m *Permission) MarshalVTStrict() (dAtA []byte, err error) {
207 if m == nil {
208 return nil, nil
209 }
210 size := m.SizeVT()
211 dAtA = make([]byte, size)
212 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
213 if err != nil {
214 return nil, err
215 }
216 return dAtA[:n], nil
217 }
218
219 func (m *Permission) MarshalToVTStrict(dAtA []byte) (int, error) {
220 size := m.SizeVT()
221 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
222 }
223
224 func (m *Permission) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
225 if m == nil {
226 return 0, nil
227 }
228 i := len(dAtA)
229 _ = i
230 var l int
231 _ = l
232 if m.unknownFields != nil {
233 i -= len(m.unknownFields)
234 copy(dAtA[i:], m.unknownFields)
235 }
236 if msg, ok := m.Rule.(*Permission_UrlPath); ok {
237 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
238 if err != nil {
239 return 0, err
240 }
241 i -= size
242 }
243 if msg, ok := m.Rule.(*Permission_RequestedServerName); ok {
244 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
245 if err != nil {
246 return 0, err
247 }
248 i -= size
249 }
250 if msg, ok := m.Rule.(*Permission_NotRule); ok {
251 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
252 if err != nil {
253 return 0, err
254 }
255 i -= size
256 }
257 if msg, ok := m.Rule.(*Permission_Metadata); ok {
258 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
259 if err != nil {
260 return 0, err
261 }
262 i -= size
263 }
264 if msg, ok := m.Rule.(*Permission_DestinationPort); ok {
265 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
266 if err != nil {
267 return 0, err
268 }
269 i -= size
270 }
271 if msg, ok := m.Rule.(*Permission_DestinationIp); ok {
272 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
273 if err != nil {
274 return 0, err
275 }
276 i -= size
277 }
278 if msg, ok := m.Rule.(*Permission_Header); ok {
279 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
280 if err != nil {
281 return 0, err
282 }
283 i -= size
284 }
285 if msg, ok := m.Rule.(*Permission_Any); ok {
286 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
287 if err != nil {
288 return 0, err
289 }
290 i -= size
291 }
292 if msg, ok := m.Rule.(*Permission_OrRules); ok {
293 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
294 if err != nil {
295 return 0, err
296 }
297 i -= size
298 }
299 if msg, ok := m.Rule.(*Permission_AndRules); ok {
300 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
301 if err != nil {
302 return 0, err
303 }
304 i -= size
305 }
306 return len(dAtA) - i, nil
307 }
308
309 func (m *Permission_AndRules) MarshalToVTStrict(dAtA []byte) (int, error) {
310 size := m.SizeVT()
311 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
312 }
313
314 func (m *Permission_AndRules) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
315 i := len(dAtA)
316 if m.AndRules != nil {
317 size, err := m.AndRules.MarshalToSizedBufferVTStrict(dAtA[:i])
318 if err != nil {
319 return 0, err
320 }
321 i -= size
322 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
323 i--
324 dAtA[i] = 0xa
325 } else {
326 i = protohelpers.EncodeVarint(dAtA, i, 0)
327 i--
328 dAtA[i] = 0xa
329 }
330 return len(dAtA) - i, nil
331 }
332 func (m *Permission_OrRules) MarshalToVTStrict(dAtA []byte) (int, error) {
333 size := m.SizeVT()
334 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
335 }
336
337 func (m *Permission_OrRules) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
338 i := len(dAtA)
339 if m.OrRules != nil {
340 size, err := m.OrRules.MarshalToSizedBufferVTStrict(dAtA[:i])
341 if err != nil {
342 return 0, err
343 }
344 i -= size
345 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
346 i--
347 dAtA[i] = 0x12
348 } else {
349 i = protohelpers.EncodeVarint(dAtA, i, 0)
350 i--
351 dAtA[i] = 0x12
352 }
353 return len(dAtA) - i, nil
354 }
355 func (m *Permission_Any) MarshalToVTStrict(dAtA []byte) (int, error) {
356 size := m.SizeVT()
357 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
358 }
359
360 func (m *Permission_Any) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
361 i := len(dAtA)
362 i--
363 if m.Any {
364 dAtA[i] = 1
365 } else {
366 dAtA[i] = 0
367 }
368 i--
369 dAtA[i] = 0x18
370 return len(dAtA) - i, nil
371 }
372 func (m *Permission_Header) MarshalToVTStrict(dAtA []byte) (int, error) {
373 size := m.SizeVT()
374 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
375 }
376
377 func (m *Permission_Header) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
378 i := len(dAtA)
379 if m.Header != nil {
380 if vtmsg, ok := interface{}(m.Header).(interface {
381 MarshalToSizedBufferVTStrict([]byte) (int, error)
382 }); ok {
383 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
384 if err != nil {
385 return 0, err
386 }
387 i -= size
388 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
389 } else {
390 encoded, err := proto.Marshal(m.Header)
391 if err != nil {
392 return 0, err
393 }
394 i -= len(encoded)
395 copy(dAtA[i:], encoded)
396 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
397 }
398 i--
399 dAtA[i] = 0x22
400 } else {
401 i = protohelpers.EncodeVarint(dAtA, i, 0)
402 i--
403 dAtA[i] = 0x22
404 }
405 return len(dAtA) - i, nil
406 }
407 func (m *Permission_DestinationIp) MarshalToVTStrict(dAtA []byte) (int, error) {
408 size := m.SizeVT()
409 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
410 }
411
412 func (m *Permission_DestinationIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
413 i := len(dAtA)
414 if m.DestinationIp != nil {
415 if vtmsg, ok := interface{}(m.DestinationIp).(interface {
416 MarshalToSizedBufferVTStrict([]byte) (int, error)
417 }); ok {
418 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
419 if err != nil {
420 return 0, err
421 }
422 i -= size
423 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
424 } else {
425 encoded, err := proto.Marshal(m.DestinationIp)
426 if err != nil {
427 return 0, err
428 }
429 i -= len(encoded)
430 copy(dAtA[i:], encoded)
431 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
432 }
433 i--
434 dAtA[i] = 0x2a
435 } else {
436 i = protohelpers.EncodeVarint(dAtA, i, 0)
437 i--
438 dAtA[i] = 0x2a
439 }
440 return len(dAtA) - i, nil
441 }
442 func (m *Permission_DestinationPort) MarshalToVTStrict(dAtA []byte) (int, error) {
443 size := m.SizeVT()
444 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
445 }
446
447 func (m *Permission_DestinationPort) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
448 i := len(dAtA)
449 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DestinationPort))
450 i--
451 dAtA[i] = 0x30
452 return len(dAtA) - i, nil
453 }
454 func (m *Permission_Metadata) MarshalToVTStrict(dAtA []byte) (int, error) {
455 size := m.SizeVT()
456 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
457 }
458
459 func (m *Permission_Metadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
460 i := len(dAtA)
461 if m.Metadata != nil {
462 if vtmsg, ok := interface{}(m.Metadata).(interface {
463 MarshalToSizedBufferVTStrict([]byte) (int, error)
464 }); ok {
465 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
466 if err != nil {
467 return 0, err
468 }
469 i -= size
470 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
471 } else {
472 encoded, err := proto.Marshal(m.Metadata)
473 if err != nil {
474 return 0, err
475 }
476 i -= len(encoded)
477 copy(dAtA[i:], encoded)
478 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
479 }
480 i--
481 dAtA[i] = 0x3a
482 } else {
483 i = protohelpers.EncodeVarint(dAtA, i, 0)
484 i--
485 dAtA[i] = 0x3a
486 }
487 return len(dAtA) - i, nil
488 }
489 func (m *Permission_NotRule) MarshalToVTStrict(dAtA []byte) (int, error) {
490 size := m.SizeVT()
491 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
492 }
493
494 func (m *Permission_NotRule) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
495 i := len(dAtA)
496 if m.NotRule != nil {
497 size, err := m.NotRule.MarshalToSizedBufferVTStrict(dAtA[:i])
498 if err != nil {
499 return 0, err
500 }
501 i -= size
502 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
503 i--
504 dAtA[i] = 0x42
505 } else {
506 i = protohelpers.EncodeVarint(dAtA, i, 0)
507 i--
508 dAtA[i] = 0x42
509 }
510 return len(dAtA) - i, nil
511 }
512 func (m *Permission_RequestedServerName) MarshalToVTStrict(dAtA []byte) (int, error) {
513 size := m.SizeVT()
514 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
515 }
516
517 func (m *Permission_RequestedServerName) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
518 i := len(dAtA)
519 if m.RequestedServerName != nil {
520 if vtmsg, ok := interface{}(m.RequestedServerName).(interface {
521 MarshalToSizedBufferVTStrict([]byte) (int, error)
522 }); ok {
523 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
524 if err != nil {
525 return 0, err
526 }
527 i -= size
528 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
529 } else {
530 encoded, err := proto.Marshal(m.RequestedServerName)
531 if err != nil {
532 return 0, err
533 }
534 i -= len(encoded)
535 copy(dAtA[i:], encoded)
536 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
537 }
538 i--
539 dAtA[i] = 0x4a
540 } else {
541 i = protohelpers.EncodeVarint(dAtA, i, 0)
542 i--
543 dAtA[i] = 0x4a
544 }
545 return len(dAtA) - i, nil
546 }
547 func (m *Permission_UrlPath) MarshalToVTStrict(dAtA []byte) (int, error) {
548 size := m.SizeVT()
549 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
550 }
551
552 func (m *Permission_UrlPath) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
553 i := len(dAtA)
554 if m.UrlPath != nil {
555 if vtmsg, ok := interface{}(m.UrlPath).(interface {
556 MarshalToSizedBufferVTStrict([]byte) (int, error)
557 }); ok {
558 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
559 if err != nil {
560 return 0, err
561 }
562 i -= size
563 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
564 } else {
565 encoded, err := proto.Marshal(m.UrlPath)
566 if err != nil {
567 return 0, err
568 }
569 i -= len(encoded)
570 copy(dAtA[i:], encoded)
571 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
572 }
573 i--
574 dAtA[i] = 0x52
575 } else {
576 i = protohelpers.EncodeVarint(dAtA, i, 0)
577 i--
578 dAtA[i] = 0x52
579 }
580 return len(dAtA) - i, nil
581 }
582 func (m *Principal_Set) MarshalVTStrict() (dAtA []byte, err error) {
583 if m == nil {
584 return nil, nil
585 }
586 size := m.SizeVT()
587 dAtA = make([]byte, size)
588 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
589 if err != nil {
590 return nil, err
591 }
592 return dAtA[:n], nil
593 }
594
595 func (m *Principal_Set) MarshalToVTStrict(dAtA []byte) (int, error) {
596 size := m.SizeVT()
597 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
598 }
599
600 func (m *Principal_Set) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
601 if m == nil {
602 return 0, nil
603 }
604 i := len(dAtA)
605 _ = i
606 var l int
607 _ = l
608 if m.unknownFields != nil {
609 i -= len(m.unknownFields)
610 copy(dAtA[i:], m.unknownFields)
611 }
612 if len(m.Ids) > 0 {
613 for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
614 size, err := m.Ids[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
615 if err != nil {
616 return 0, err
617 }
618 i -= size
619 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
620 i--
621 dAtA[i] = 0xa
622 }
623 }
624 return len(dAtA) - i, nil
625 }
626
627 func (m *Principal_Authenticated) MarshalVTStrict() (dAtA []byte, err error) {
628 if m == nil {
629 return nil, nil
630 }
631 size := m.SizeVT()
632 dAtA = make([]byte, size)
633 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
634 if err != nil {
635 return nil, err
636 }
637 return dAtA[:n], nil
638 }
639
640 func (m *Principal_Authenticated) MarshalToVTStrict(dAtA []byte) (int, error) {
641 size := m.SizeVT()
642 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
643 }
644
645 func (m *Principal_Authenticated) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
646 if m == nil {
647 return 0, nil
648 }
649 i := len(dAtA)
650 _ = i
651 var l int
652 _ = l
653 if m.unknownFields != nil {
654 i -= len(m.unknownFields)
655 copy(dAtA[i:], m.unknownFields)
656 }
657 if m.PrincipalName != nil {
658 if vtmsg, ok := interface{}(m.PrincipalName).(interface {
659 MarshalToSizedBufferVTStrict([]byte) (int, error)
660 }); ok {
661 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
662 if err != nil {
663 return 0, err
664 }
665 i -= size
666 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
667 } else {
668 encoded, err := proto.Marshal(m.PrincipalName)
669 if err != nil {
670 return 0, err
671 }
672 i -= len(encoded)
673 copy(dAtA[i:], encoded)
674 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
675 }
676 i--
677 dAtA[i] = 0x12
678 }
679 return len(dAtA) - i, nil
680 }
681
682 func (m *Principal) MarshalVTStrict() (dAtA []byte, err error) {
683 if m == nil {
684 return nil, nil
685 }
686 size := m.SizeVT()
687 dAtA = make([]byte, size)
688 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
689 if err != nil {
690 return nil, err
691 }
692 return dAtA[:n], nil
693 }
694
695 func (m *Principal) MarshalToVTStrict(dAtA []byte) (int, error) {
696 size := m.SizeVT()
697 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
698 }
699
700 func (m *Principal) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
701 if m == nil {
702 return 0, nil
703 }
704 i := len(dAtA)
705 _ = i
706 var l int
707 _ = l
708 if m.unknownFields != nil {
709 i -= len(m.unknownFields)
710 copy(dAtA[i:], m.unknownFields)
711 }
712 if msg, ok := m.Identifier.(*Principal_RemoteIp); ok {
713 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
714 if err != nil {
715 return 0, err
716 }
717 i -= size
718 }
719 if msg, ok := m.Identifier.(*Principal_DirectRemoteIp); ok {
720 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
721 if err != nil {
722 return 0, err
723 }
724 i -= size
725 }
726 if msg, ok := m.Identifier.(*Principal_UrlPath); ok {
727 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
728 if err != nil {
729 return 0, err
730 }
731 i -= size
732 }
733 if msg, ok := m.Identifier.(*Principal_NotId); ok {
734 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
735 if err != nil {
736 return 0, err
737 }
738 i -= size
739 }
740 if msg, ok := m.Identifier.(*Principal_Metadata); ok {
741 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
742 if err != nil {
743 return 0, err
744 }
745 i -= size
746 }
747 if msg, ok := m.Identifier.(*Principal_Header); ok {
748 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
749 if err != nil {
750 return 0, err
751 }
752 i -= size
753 }
754 if msg, ok := m.Identifier.(*Principal_SourceIp); ok {
755 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
756 if err != nil {
757 return 0, err
758 }
759 i -= size
760 }
761 if msg, ok := m.Identifier.(*Principal_Authenticated_); ok {
762 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
763 if err != nil {
764 return 0, err
765 }
766 i -= size
767 }
768 if msg, ok := m.Identifier.(*Principal_Any); ok {
769 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
770 if err != nil {
771 return 0, err
772 }
773 i -= size
774 }
775 if msg, ok := m.Identifier.(*Principal_OrIds); ok {
776 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
777 if err != nil {
778 return 0, err
779 }
780 i -= size
781 }
782 if msg, ok := m.Identifier.(*Principal_AndIds); ok {
783 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
784 if err != nil {
785 return 0, err
786 }
787 i -= size
788 }
789 return len(dAtA) - i, nil
790 }
791
792 func (m *Principal_AndIds) MarshalToVTStrict(dAtA []byte) (int, error) {
793 size := m.SizeVT()
794 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
795 }
796
797 func (m *Principal_AndIds) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
798 i := len(dAtA)
799 if m.AndIds != nil {
800 size, err := m.AndIds.MarshalToSizedBufferVTStrict(dAtA[:i])
801 if err != nil {
802 return 0, err
803 }
804 i -= size
805 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
806 i--
807 dAtA[i] = 0xa
808 } else {
809 i = protohelpers.EncodeVarint(dAtA, i, 0)
810 i--
811 dAtA[i] = 0xa
812 }
813 return len(dAtA) - i, nil
814 }
815 func (m *Principal_OrIds) MarshalToVTStrict(dAtA []byte) (int, error) {
816 size := m.SizeVT()
817 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
818 }
819
820 func (m *Principal_OrIds) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
821 i := len(dAtA)
822 if m.OrIds != nil {
823 size, err := m.OrIds.MarshalToSizedBufferVTStrict(dAtA[:i])
824 if err != nil {
825 return 0, err
826 }
827 i -= size
828 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
829 i--
830 dAtA[i] = 0x12
831 } else {
832 i = protohelpers.EncodeVarint(dAtA, i, 0)
833 i--
834 dAtA[i] = 0x12
835 }
836 return len(dAtA) - i, nil
837 }
838 func (m *Principal_Any) MarshalToVTStrict(dAtA []byte) (int, error) {
839 size := m.SizeVT()
840 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
841 }
842
843 func (m *Principal_Any) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
844 i := len(dAtA)
845 i--
846 if m.Any {
847 dAtA[i] = 1
848 } else {
849 dAtA[i] = 0
850 }
851 i--
852 dAtA[i] = 0x18
853 return len(dAtA) - i, nil
854 }
855 func (m *Principal_Authenticated_) MarshalToVTStrict(dAtA []byte) (int, error) {
856 size := m.SizeVT()
857 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
858 }
859
860 func (m *Principal_Authenticated_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
861 i := len(dAtA)
862 if m.Authenticated != nil {
863 size, err := m.Authenticated.MarshalToSizedBufferVTStrict(dAtA[:i])
864 if err != nil {
865 return 0, err
866 }
867 i -= size
868 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
869 i--
870 dAtA[i] = 0x22
871 } else {
872 i = protohelpers.EncodeVarint(dAtA, i, 0)
873 i--
874 dAtA[i] = 0x22
875 }
876 return len(dAtA) - i, nil
877 }
878 func (m *Principal_SourceIp) MarshalToVTStrict(dAtA []byte) (int, error) {
879 size := m.SizeVT()
880 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
881 }
882
883 func (m *Principal_SourceIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
884 i := len(dAtA)
885 if m.SourceIp != nil {
886 if vtmsg, ok := interface{}(m.SourceIp).(interface {
887 MarshalToSizedBufferVTStrict([]byte) (int, error)
888 }); ok {
889 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
890 if err != nil {
891 return 0, err
892 }
893 i -= size
894 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
895 } else {
896 encoded, err := proto.Marshal(m.SourceIp)
897 if err != nil {
898 return 0, err
899 }
900 i -= len(encoded)
901 copy(dAtA[i:], encoded)
902 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
903 }
904 i--
905 dAtA[i] = 0x2a
906 } else {
907 i = protohelpers.EncodeVarint(dAtA, i, 0)
908 i--
909 dAtA[i] = 0x2a
910 }
911 return len(dAtA) - i, nil
912 }
913 func (m *Principal_Header) MarshalToVTStrict(dAtA []byte) (int, error) {
914 size := m.SizeVT()
915 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
916 }
917
918 func (m *Principal_Header) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
919 i := len(dAtA)
920 if m.Header != nil {
921 if vtmsg, ok := interface{}(m.Header).(interface {
922 MarshalToSizedBufferVTStrict([]byte) (int, error)
923 }); ok {
924 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
925 if err != nil {
926 return 0, err
927 }
928 i -= size
929 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
930 } else {
931 encoded, err := proto.Marshal(m.Header)
932 if err != nil {
933 return 0, err
934 }
935 i -= len(encoded)
936 copy(dAtA[i:], encoded)
937 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
938 }
939 i--
940 dAtA[i] = 0x32
941 } else {
942 i = protohelpers.EncodeVarint(dAtA, i, 0)
943 i--
944 dAtA[i] = 0x32
945 }
946 return len(dAtA) - i, nil
947 }
948 func (m *Principal_Metadata) MarshalToVTStrict(dAtA []byte) (int, error) {
949 size := m.SizeVT()
950 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
951 }
952
953 func (m *Principal_Metadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
954 i := len(dAtA)
955 if m.Metadata != nil {
956 if vtmsg, ok := interface{}(m.Metadata).(interface {
957 MarshalToSizedBufferVTStrict([]byte) (int, error)
958 }); ok {
959 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
960 if err != nil {
961 return 0, err
962 }
963 i -= size
964 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
965 } else {
966 encoded, err := proto.Marshal(m.Metadata)
967 if err != nil {
968 return 0, err
969 }
970 i -= len(encoded)
971 copy(dAtA[i:], encoded)
972 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
973 }
974 i--
975 dAtA[i] = 0x3a
976 } else {
977 i = protohelpers.EncodeVarint(dAtA, i, 0)
978 i--
979 dAtA[i] = 0x3a
980 }
981 return len(dAtA) - i, nil
982 }
983 func (m *Principal_NotId) MarshalToVTStrict(dAtA []byte) (int, error) {
984 size := m.SizeVT()
985 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
986 }
987
988 func (m *Principal_NotId) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
989 i := len(dAtA)
990 if m.NotId != nil {
991 size, err := m.NotId.MarshalToSizedBufferVTStrict(dAtA[:i])
992 if err != nil {
993 return 0, err
994 }
995 i -= size
996 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
997 i--
998 dAtA[i] = 0x42
999 } else {
1000 i = protohelpers.EncodeVarint(dAtA, i, 0)
1001 i--
1002 dAtA[i] = 0x42
1003 }
1004 return len(dAtA) - i, nil
1005 }
1006 func (m *Principal_UrlPath) MarshalToVTStrict(dAtA []byte) (int, error) {
1007 size := m.SizeVT()
1008 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1009 }
1010
1011 func (m *Principal_UrlPath) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1012 i := len(dAtA)
1013 if m.UrlPath != nil {
1014 if vtmsg, ok := interface{}(m.UrlPath).(interface {
1015 MarshalToSizedBufferVTStrict([]byte) (int, error)
1016 }); ok {
1017 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1018 if err != nil {
1019 return 0, err
1020 }
1021 i -= size
1022 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1023 } else {
1024 encoded, err := proto.Marshal(m.UrlPath)
1025 if err != nil {
1026 return 0, err
1027 }
1028 i -= len(encoded)
1029 copy(dAtA[i:], encoded)
1030 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1031 }
1032 i--
1033 dAtA[i] = 0x4a
1034 } else {
1035 i = protohelpers.EncodeVarint(dAtA, i, 0)
1036 i--
1037 dAtA[i] = 0x4a
1038 }
1039 return len(dAtA) - i, nil
1040 }
1041 func (m *Principal_DirectRemoteIp) MarshalToVTStrict(dAtA []byte) (int, error) {
1042 size := m.SizeVT()
1043 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1044 }
1045
1046 func (m *Principal_DirectRemoteIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1047 i := len(dAtA)
1048 if m.DirectRemoteIp != nil {
1049 if vtmsg, ok := interface{}(m.DirectRemoteIp).(interface {
1050 MarshalToSizedBufferVTStrict([]byte) (int, error)
1051 }); ok {
1052 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1053 if err != nil {
1054 return 0, err
1055 }
1056 i -= size
1057 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1058 } else {
1059 encoded, err := proto.Marshal(m.DirectRemoteIp)
1060 if err != nil {
1061 return 0, err
1062 }
1063 i -= len(encoded)
1064 copy(dAtA[i:], encoded)
1065 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1066 }
1067 i--
1068 dAtA[i] = 0x52
1069 } else {
1070 i = protohelpers.EncodeVarint(dAtA, i, 0)
1071 i--
1072 dAtA[i] = 0x52
1073 }
1074 return len(dAtA) - i, nil
1075 }
1076 func (m *Principal_RemoteIp) MarshalToVTStrict(dAtA []byte) (int, error) {
1077 size := m.SizeVT()
1078 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1079 }
1080
1081 func (m *Principal_RemoteIp) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1082 i := len(dAtA)
1083 if m.RemoteIp != nil {
1084 if vtmsg, ok := interface{}(m.RemoteIp).(interface {
1085 MarshalToSizedBufferVTStrict([]byte) (int, error)
1086 }); ok {
1087 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1088 if err != nil {
1089 return 0, err
1090 }
1091 i -= size
1092 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1093 } else {
1094 encoded, err := proto.Marshal(m.RemoteIp)
1095 if err != nil {
1096 return 0, err
1097 }
1098 i -= len(encoded)
1099 copy(dAtA[i:], encoded)
1100 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1101 }
1102 i--
1103 dAtA[i] = 0x5a
1104 } else {
1105 i = protohelpers.EncodeVarint(dAtA, i, 0)
1106 i--
1107 dAtA[i] = 0x5a
1108 }
1109 return len(dAtA) - i, nil
1110 }
1111 func (m *RBAC) SizeVT() (n int) {
1112 if m == nil {
1113 return 0
1114 }
1115 var l int
1116 _ = l
1117 if m.Action != 0 {
1118 n += 1 + protohelpers.SizeOfVarint(uint64(m.Action))
1119 }
1120 if len(m.Policies) > 0 {
1121 for k, v := range m.Policies {
1122 _ = k
1123 _ = v
1124 l = 0
1125 if v != nil {
1126 l = v.SizeVT()
1127 }
1128 l += 1 + protohelpers.SizeOfVarint(uint64(l))
1129 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
1130 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
1131 }
1132 }
1133 n += len(m.unknownFields)
1134 return n
1135 }
1136
1137 func (m *Policy) SizeVT() (n int) {
1138 if m == nil {
1139 return 0
1140 }
1141 var l int
1142 _ = l
1143 if len(m.Permissions) > 0 {
1144 for _, e := range m.Permissions {
1145 l = e.SizeVT()
1146 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1147 }
1148 }
1149 if len(m.Principals) > 0 {
1150 for _, e := range m.Principals {
1151 l = e.SizeVT()
1152 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1153 }
1154 }
1155 if m.Condition != nil {
1156 if size, ok := interface{}(m.Condition).(interface {
1157 SizeVT() int
1158 }); ok {
1159 l = size.SizeVT()
1160 } else {
1161 l = proto.Size(m.Condition)
1162 }
1163 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1164 }
1165 n += len(m.unknownFields)
1166 return n
1167 }
1168
1169 func (m *Permission_Set) SizeVT() (n int) {
1170 if m == nil {
1171 return 0
1172 }
1173 var l int
1174 _ = l
1175 if len(m.Rules) > 0 {
1176 for _, e := range m.Rules {
1177 l = e.SizeVT()
1178 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1179 }
1180 }
1181 n += len(m.unknownFields)
1182 return n
1183 }
1184
1185 func (m *Permission) SizeVT() (n int) {
1186 if m == nil {
1187 return 0
1188 }
1189 var l int
1190 _ = l
1191 if vtmsg, ok := m.Rule.(interface{ SizeVT() int }); ok {
1192 n += vtmsg.SizeVT()
1193 }
1194 n += len(m.unknownFields)
1195 return n
1196 }
1197
1198 func (m *Permission_AndRules) SizeVT() (n int) {
1199 if m == nil {
1200 return 0
1201 }
1202 var l int
1203 _ = l
1204 if m.AndRules != nil {
1205 l = m.AndRules.SizeVT()
1206 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1207 } else {
1208 n += 2
1209 }
1210 return n
1211 }
1212 func (m *Permission_OrRules) SizeVT() (n int) {
1213 if m == nil {
1214 return 0
1215 }
1216 var l int
1217 _ = l
1218 if m.OrRules != nil {
1219 l = m.OrRules.SizeVT()
1220 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1221 } else {
1222 n += 2
1223 }
1224 return n
1225 }
1226 func (m *Permission_Any) SizeVT() (n int) {
1227 if m == nil {
1228 return 0
1229 }
1230 var l int
1231 _ = l
1232 n += 2
1233 return n
1234 }
1235 func (m *Permission_Header) SizeVT() (n int) {
1236 if m == nil {
1237 return 0
1238 }
1239 var l int
1240 _ = l
1241 if m.Header != nil {
1242 if size, ok := interface{}(m.Header).(interface {
1243 SizeVT() int
1244 }); ok {
1245 l = size.SizeVT()
1246 } else {
1247 l = proto.Size(m.Header)
1248 }
1249 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1250 } else {
1251 n += 2
1252 }
1253 return n
1254 }
1255 func (m *Permission_DestinationIp) SizeVT() (n int) {
1256 if m == nil {
1257 return 0
1258 }
1259 var l int
1260 _ = l
1261 if m.DestinationIp != nil {
1262 if size, ok := interface{}(m.DestinationIp).(interface {
1263 SizeVT() int
1264 }); ok {
1265 l = size.SizeVT()
1266 } else {
1267 l = proto.Size(m.DestinationIp)
1268 }
1269 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1270 } else {
1271 n += 2
1272 }
1273 return n
1274 }
1275 func (m *Permission_DestinationPort) SizeVT() (n int) {
1276 if m == nil {
1277 return 0
1278 }
1279 var l int
1280 _ = l
1281 n += 1 + protohelpers.SizeOfVarint(uint64(m.DestinationPort))
1282 return n
1283 }
1284 func (m *Permission_Metadata) SizeVT() (n int) {
1285 if m == nil {
1286 return 0
1287 }
1288 var l int
1289 _ = l
1290 if m.Metadata != nil {
1291 if size, ok := interface{}(m.Metadata).(interface {
1292 SizeVT() int
1293 }); ok {
1294 l = size.SizeVT()
1295 } else {
1296 l = proto.Size(m.Metadata)
1297 }
1298 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1299 } else {
1300 n += 2
1301 }
1302 return n
1303 }
1304 func (m *Permission_NotRule) SizeVT() (n int) {
1305 if m == nil {
1306 return 0
1307 }
1308 var l int
1309 _ = l
1310 if m.NotRule != nil {
1311 l = m.NotRule.SizeVT()
1312 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1313 } else {
1314 n += 2
1315 }
1316 return n
1317 }
1318 func (m *Permission_RequestedServerName) SizeVT() (n int) {
1319 if m == nil {
1320 return 0
1321 }
1322 var l int
1323 _ = l
1324 if m.RequestedServerName != nil {
1325 if size, ok := interface{}(m.RequestedServerName).(interface {
1326 SizeVT() int
1327 }); ok {
1328 l = size.SizeVT()
1329 } else {
1330 l = proto.Size(m.RequestedServerName)
1331 }
1332 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1333 } else {
1334 n += 2
1335 }
1336 return n
1337 }
1338 func (m *Permission_UrlPath) SizeVT() (n int) {
1339 if m == nil {
1340 return 0
1341 }
1342 var l int
1343 _ = l
1344 if m.UrlPath != nil {
1345 if size, ok := interface{}(m.UrlPath).(interface {
1346 SizeVT() int
1347 }); ok {
1348 l = size.SizeVT()
1349 } else {
1350 l = proto.Size(m.UrlPath)
1351 }
1352 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1353 } else {
1354 n += 2
1355 }
1356 return n
1357 }
1358 func (m *Principal_Set) SizeVT() (n int) {
1359 if m == nil {
1360 return 0
1361 }
1362 var l int
1363 _ = l
1364 if len(m.Ids) > 0 {
1365 for _, e := range m.Ids {
1366 l = e.SizeVT()
1367 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1368 }
1369 }
1370 n += len(m.unknownFields)
1371 return n
1372 }
1373
1374 func (m *Principal_Authenticated) SizeVT() (n int) {
1375 if m == nil {
1376 return 0
1377 }
1378 var l int
1379 _ = l
1380 if m.PrincipalName != nil {
1381 if size, ok := interface{}(m.PrincipalName).(interface {
1382 SizeVT() int
1383 }); ok {
1384 l = size.SizeVT()
1385 } else {
1386 l = proto.Size(m.PrincipalName)
1387 }
1388 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1389 }
1390 n += len(m.unknownFields)
1391 return n
1392 }
1393
1394 func (m *Principal) SizeVT() (n int) {
1395 if m == nil {
1396 return 0
1397 }
1398 var l int
1399 _ = l
1400 if vtmsg, ok := m.Identifier.(interface{ SizeVT() int }); ok {
1401 n += vtmsg.SizeVT()
1402 }
1403 n += len(m.unknownFields)
1404 return n
1405 }
1406
1407 func (m *Principal_AndIds) SizeVT() (n int) {
1408 if m == nil {
1409 return 0
1410 }
1411 var l int
1412 _ = l
1413 if m.AndIds != nil {
1414 l = m.AndIds.SizeVT()
1415 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1416 } else {
1417 n += 2
1418 }
1419 return n
1420 }
1421 func (m *Principal_OrIds) SizeVT() (n int) {
1422 if m == nil {
1423 return 0
1424 }
1425 var l int
1426 _ = l
1427 if m.OrIds != nil {
1428 l = m.OrIds.SizeVT()
1429 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1430 } else {
1431 n += 2
1432 }
1433 return n
1434 }
1435 func (m *Principal_Any) SizeVT() (n int) {
1436 if m == nil {
1437 return 0
1438 }
1439 var l int
1440 _ = l
1441 n += 2
1442 return n
1443 }
1444 func (m *Principal_Authenticated_) SizeVT() (n int) {
1445 if m == nil {
1446 return 0
1447 }
1448 var l int
1449 _ = l
1450 if m.Authenticated != nil {
1451 l = m.Authenticated.SizeVT()
1452 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1453 } else {
1454 n += 2
1455 }
1456 return n
1457 }
1458 func (m *Principal_SourceIp) SizeVT() (n int) {
1459 if m == nil {
1460 return 0
1461 }
1462 var l int
1463 _ = l
1464 if m.SourceIp != nil {
1465 if size, ok := interface{}(m.SourceIp).(interface {
1466 SizeVT() int
1467 }); ok {
1468 l = size.SizeVT()
1469 } else {
1470 l = proto.Size(m.SourceIp)
1471 }
1472 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1473 } else {
1474 n += 2
1475 }
1476 return n
1477 }
1478 func (m *Principal_Header) SizeVT() (n int) {
1479 if m == nil {
1480 return 0
1481 }
1482 var l int
1483 _ = l
1484 if m.Header != nil {
1485 if size, ok := interface{}(m.Header).(interface {
1486 SizeVT() int
1487 }); ok {
1488 l = size.SizeVT()
1489 } else {
1490 l = proto.Size(m.Header)
1491 }
1492 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1493 } else {
1494 n += 2
1495 }
1496 return n
1497 }
1498 func (m *Principal_Metadata) SizeVT() (n int) {
1499 if m == nil {
1500 return 0
1501 }
1502 var l int
1503 _ = l
1504 if m.Metadata != nil {
1505 if size, ok := interface{}(m.Metadata).(interface {
1506 SizeVT() int
1507 }); ok {
1508 l = size.SizeVT()
1509 } else {
1510 l = proto.Size(m.Metadata)
1511 }
1512 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1513 } else {
1514 n += 2
1515 }
1516 return n
1517 }
1518 func (m *Principal_NotId) SizeVT() (n int) {
1519 if m == nil {
1520 return 0
1521 }
1522 var l int
1523 _ = l
1524 if m.NotId != nil {
1525 l = m.NotId.SizeVT()
1526 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1527 } else {
1528 n += 2
1529 }
1530 return n
1531 }
1532 func (m *Principal_UrlPath) SizeVT() (n int) {
1533 if m == nil {
1534 return 0
1535 }
1536 var l int
1537 _ = l
1538 if m.UrlPath != nil {
1539 if size, ok := interface{}(m.UrlPath).(interface {
1540 SizeVT() int
1541 }); ok {
1542 l = size.SizeVT()
1543 } else {
1544 l = proto.Size(m.UrlPath)
1545 }
1546 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1547 } else {
1548 n += 2
1549 }
1550 return n
1551 }
1552 func (m *Principal_DirectRemoteIp) SizeVT() (n int) {
1553 if m == nil {
1554 return 0
1555 }
1556 var l int
1557 _ = l
1558 if m.DirectRemoteIp != nil {
1559 if size, ok := interface{}(m.DirectRemoteIp).(interface {
1560 SizeVT() int
1561 }); ok {
1562 l = size.SizeVT()
1563 } else {
1564 l = proto.Size(m.DirectRemoteIp)
1565 }
1566 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1567 } else {
1568 n += 2
1569 }
1570 return n
1571 }
1572 func (m *Principal_RemoteIp) SizeVT() (n int) {
1573 if m == nil {
1574 return 0
1575 }
1576 var l int
1577 _ = l
1578 if m.RemoteIp != nil {
1579 if size, ok := interface{}(m.RemoteIp).(interface {
1580 SizeVT() int
1581 }); ok {
1582 l = size.SizeVT()
1583 } else {
1584 l = proto.Size(m.RemoteIp)
1585 }
1586 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1587 } else {
1588 n += 2
1589 }
1590 return n
1591 }