Debian Codegraph @

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