Debian Codegraph @

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