Debian Codegraph @

envoy/service/status/v2/csds_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/status/v2/csds.proto
6
7 package statusv2
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 *ClientStatusRequest) 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 *ClientStatusRequest) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *ClientStatusRequest) 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.NodeMatchers) > 0 {
53 for iNdEx := len(m.NodeMatchers) - 1; iNdEx >= 0; iNdEx-- {
54 if vtmsg, ok := interface{}(m.NodeMatchers[iNdEx]).(interface {
55 MarshalToSizedBufferVTStrict([]byte) (int, error)
56 }); ok {
57 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
58 if err != nil {
59 return 0, err
60 }
61 i -= size
62 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
63 } else {
64 encoded, err := proto.Marshal(m.NodeMatchers[iNdEx])
65 if err != nil {
66 return 0, err
67 }
68 i -= len(encoded)
69 copy(dAtA[i:], encoded)
70 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
71 }
72 i--
73 dAtA[i] = 0xa
74 }
75 }
76 return len(dAtA) - i, nil
77 }
78
79 func (m *PerXdsConfig) MarshalVTStrict() (dAtA []byte, err error) {
80 if m == nil {
81 return nil, nil
82 }
83 size := m.SizeVT()
84 dAtA = make([]byte, size)
85 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
86 if err != nil {
87 return nil, err
88 }
89 return dAtA[:n], nil
90 }
91
92 func (m *PerXdsConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
93 size := m.SizeVT()
94 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
95 }
96
97 func (m *PerXdsConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
98 if m == nil {
99 return 0, nil
100 }
101 i := len(dAtA)
102 _ = i
103 var l int
104 _ = l
105 if m.unknownFields != nil {
106 i -= len(m.unknownFields)
107 copy(dAtA[i:], m.unknownFields)
108 }
109 if msg, ok := m.PerXdsConfig.(*PerXdsConfig_ScopedRouteConfig); ok {
110 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
111 if err != nil {
112 return 0, err
113 }
114 i -= size
115 }
116 if msg, ok := m.PerXdsConfig.(*PerXdsConfig_RouteConfig); ok {
117 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
118 if err != nil {
119 return 0, err
120 }
121 i -= size
122 }
123 if msg, ok := m.PerXdsConfig.(*PerXdsConfig_ClusterConfig); ok {
124 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
125 if err != nil {
126 return 0, err
127 }
128 i -= size
129 }
130 if msg, ok := m.PerXdsConfig.(*PerXdsConfig_ListenerConfig); ok {
131 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
132 if err != nil {
133 return 0, err
134 }
135 i -= size
136 }
137 if m.Status != 0 {
138 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status))
139 i--
140 dAtA[i] = 0x8
141 }
142 return len(dAtA) - i, nil
143 }
144
145 func (m *PerXdsConfig_ListenerConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
146 size := m.SizeVT()
147 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
148 }
149
150 func (m *PerXdsConfig_ListenerConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
151 i := len(dAtA)
152 if m.ListenerConfig != nil {
153 if vtmsg, ok := interface{}(m.ListenerConfig).(interface {
154 MarshalToSizedBufferVTStrict([]byte) (int, error)
155 }); ok {
156 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
157 if err != nil {
158 return 0, err
159 }
160 i -= size
161 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
162 } else {
163 encoded, err := proto.Marshal(m.ListenerConfig)
164 if err != nil {
165 return 0, err
166 }
167 i -= len(encoded)
168 copy(dAtA[i:], encoded)
169 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
170 }
171 i--
172 dAtA[i] = 0x12
173 } else {
174 i = protohelpers.EncodeVarint(dAtA, i, 0)
175 i--
176 dAtA[i] = 0x12
177 }
178 return len(dAtA) - i, nil
179 }
180 func (m *PerXdsConfig_ClusterConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
181 size := m.SizeVT()
182 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
183 }
184
185 func (m *PerXdsConfig_ClusterConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
186 i := len(dAtA)
187 if m.ClusterConfig != nil {
188 if vtmsg, ok := interface{}(m.ClusterConfig).(interface {
189 MarshalToSizedBufferVTStrict([]byte) (int, error)
190 }); ok {
191 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
192 if err != nil {
193 return 0, err
194 }
195 i -= size
196 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
197 } else {
198 encoded, err := proto.Marshal(m.ClusterConfig)
199 if err != nil {
200 return 0, err
201 }
202 i -= len(encoded)
203 copy(dAtA[i:], encoded)
204 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
205 }
206 i--
207 dAtA[i] = 0x1a
208 } else {
209 i = protohelpers.EncodeVarint(dAtA, i, 0)
210 i--
211 dAtA[i] = 0x1a
212 }
213 return len(dAtA) - i, nil
214 }
215 func (m *PerXdsConfig_RouteConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
216 size := m.SizeVT()
217 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
218 }
219
220 func (m *PerXdsConfig_RouteConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
221 i := len(dAtA)
222 if m.RouteConfig != nil {
223 if vtmsg, ok := interface{}(m.RouteConfig).(interface {
224 MarshalToSizedBufferVTStrict([]byte) (int, error)
225 }); ok {
226 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
227 if err != nil {
228 return 0, err
229 }
230 i -= size
231 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
232 } else {
233 encoded, err := proto.Marshal(m.RouteConfig)
234 if err != nil {
235 return 0, err
236 }
237 i -= len(encoded)
238 copy(dAtA[i:], encoded)
239 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
240 }
241 i--
242 dAtA[i] = 0x22
243 } else {
244 i = protohelpers.EncodeVarint(dAtA, i, 0)
245 i--
246 dAtA[i] = 0x22
247 }
248 return len(dAtA) - i, nil
249 }
250 func (m *PerXdsConfig_ScopedRouteConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
251 size := m.SizeVT()
252 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
253 }
254
255 func (m *PerXdsConfig_ScopedRouteConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
256 i := len(dAtA)
257 if m.ScopedRouteConfig != nil {
258 if vtmsg, ok := interface{}(m.ScopedRouteConfig).(interface {
259 MarshalToSizedBufferVTStrict([]byte) (int, error)
260 }); ok {
261 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
262 if err != nil {
263 return 0, err
264 }
265 i -= size
266 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
267 } else {
268 encoded, err := proto.Marshal(m.ScopedRouteConfig)
269 if err != nil {
270 return 0, err
271 }
272 i -= len(encoded)
273 copy(dAtA[i:], encoded)
274 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
275 }
276 i--
277 dAtA[i] = 0x2a
278 } else {
279 i = protohelpers.EncodeVarint(dAtA, i, 0)
280 i--
281 dAtA[i] = 0x2a
282 }
283 return len(dAtA) - i, nil
284 }
285 func (m *ClientConfig) MarshalVTStrict() (dAtA []byte, err error) {
286 if m == nil {
287 return nil, nil
288 }
289 size := m.SizeVT()
290 dAtA = make([]byte, size)
291 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
292 if err != nil {
293 return nil, err
294 }
295 return dAtA[:n], nil
296 }
297
298 func (m *ClientConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
299 size := m.SizeVT()
300 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
301 }
302
303 func (m *ClientConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
304 if m == nil {
305 return 0, nil
306 }
307 i := len(dAtA)
308 _ = i
309 var l int
310 _ = l
311 if m.unknownFields != nil {
312 i -= len(m.unknownFields)
313 copy(dAtA[i:], m.unknownFields)
314 }
315 if len(m.XdsConfig) > 0 {
316 for iNdEx := len(m.XdsConfig) - 1; iNdEx >= 0; iNdEx-- {
317 size, err := m.XdsConfig[iNdEx].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] = 0x12
325 }
326 }
327 if m.Node != nil {
328 if vtmsg, ok := interface{}(m.Node).(interface {
329 MarshalToSizedBufferVTStrict([]byte) (int, error)
330 }); ok {
331 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
332 if err != nil {
333 return 0, err
334 }
335 i -= size
336 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
337 } else {
338 encoded, err := proto.Marshal(m.Node)
339 if err != nil {
340 return 0, err
341 }
342 i -= len(encoded)
343 copy(dAtA[i:], encoded)
344 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
345 }
346 i--
347 dAtA[i] = 0xa
348 }
349 return len(dAtA) - i, nil
350 }
351
352 func (m *ClientStatusResponse) MarshalVTStrict() (dAtA []byte, err error) {
353 if m == nil {
354 return nil, nil
355 }
356 size := m.SizeVT()
357 dAtA = make([]byte, size)
358 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
359 if err != nil {
360 return nil, err
361 }
362 return dAtA[:n], nil
363 }
364
365 func (m *ClientStatusResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
366 size := m.SizeVT()
367 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
368 }
369
370 func (m *ClientStatusResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
371 if m == nil {
372 return 0, nil
373 }
374 i := len(dAtA)
375 _ = i
376 var l int
377 _ = l
378 if m.unknownFields != nil {
379 i -= len(m.unknownFields)
380 copy(dAtA[i:], m.unknownFields)
381 }
382 if len(m.Config) > 0 {
383 for iNdEx := len(m.Config) - 1; iNdEx >= 0; iNdEx-- {
384 size, err := m.Config[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
385 if err != nil {
386 return 0, err
387 }
388 i -= size
389 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
390 i--
391 dAtA[i] = 0xa
392 }
393 }
394 return len(dAtA) - i, nil
395 }
396
397 func (m *ClientStatusRequest) SizeVT() (n int) {
398 if m == nil {
399 return 0
400 }
401 var l int
402 _ = l
403 if len(m.NodeMatchers) > 0 {
404 for _, e := range m.NodeMatchers {
405 if size, ok := interface{}(e).(interface {
406 SizeVT() int
407 }); ok {
408 l = size.SizeVT()
409 } else {
410 l = proto.Size(e)
411 }
412 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
413 }
414 }
415 n += len(m.unknownFields)
416 return n
417 }
418
419 func (m *PerXdsConfig) SizeVT() (n int) {
420 if m == nil {
421 return 0
422 }
423 var l int
424 _ = l
425 if m.Status != 0 {
426 n += 1 + protohelpers.SizeOfVarint(uint64(m.Status))
427 }
428 if vtmsg, ok := m.PerXdsConfig.(interface{ SizeVT() int }); ok {
429 n += vtmsg.SizeVT()
430 }
431 n += len(m.unknownFields)
432 return n
433 }
434
435 func (m *PerXdsConfig_ListenerConfig) SizeVT() (n int) {
436 if m == nil {
437 return 0
438 }
439 var l int
440 _ = l
441 if m.ListenerConfig != nil {
442 if size, ok := interface{}(m.ListenerConfig).(interface {
443 SizeVT() int
444 }); ok {
445 l = size.SizeVT()
446 } else {
447 l = proto.Size(m.ListenerConfig)
448 }
449 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
450 } else {
451 n += 2
452 }
453 return n
454 }
455 func (m *PerXdsConfig_ClusterConfig) SizeVT() (n int) {
456 if m == nil {
457 return 0
458 }
459 var l int
460 _ = l
461 if m.ClusterConfig != nil {
462 if size, ok := interface{}(m.ClusterConfig).(interface {
463 SizeVT() int
464 }); ok {
465 l = size.SizeVT()
466 } else {
467 l = proto.Size(m.ClusterConfig)
468 }
469 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
470 } else {
471 n += 2
472 }
473 return n
474 }
475 func (m *PerXdsConfig_RouteConfig) SizeVT() (n int) {
476 if m == nil {
477 return 0
478 }
479 var l int
480 _ = l
481 if m.RouteConfig != nil {
482 if size, ok := interface{}(m.RouteConfig).(interface {
483 SizeVT() int
484 }); ok {
485 l = size.SizeVT()
486 } else {
487 l = proto.Size(m.RouteConfig)
488 }
489 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
490 } else {
491 n += 2
492 }
493 return n
494 }
495 func (m *PerXdsConfig_ScopedRouteConfig) SizeVT() (n int) {
496 if m == nil {
497 return 0
498 }
499 var l int
500 _ = l
501 if m.ScopedRouteConfig != nil {
502 if size, ok := interface{}(m.ScopedRouteConfig).(interface {
503 SizeVT() int
504 }); ok {
505 l = size.SizeVT()
506 } else {
507 l = proto.Size(m.ScopedRouteConfig)
508 }
509 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
510 } else {
511 n += 2
512 }
513 return n
514 }
515 func (m *ClientConfig) SizeVT() (n int) {
516 if m == nil {
517 return 0
518 }
519 var l int
520 _ = l
521 if m.Node != nil {
522 if size, ok := interface{}(m.Node).(interface {
523 SizeVT() int
524 }); ok {
525 l = size.SizeVT()
526 } else {
527 l = proto.Size(m.Node)
528 }
529 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
530 }
531 if len(m.XdsConfig) > 0 {
532 for _, e := range m.XdsConfig {
533 l = e.SizeVT()
534 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
535 }
536 }
537 n += len(m.unknownFields)
538 return n
539 }
540
541 func (m *ClientStatusResponse) SizeVT() (n int) {
542 if m == nil {
543 return 0
544 }
545 var l int
546 _ = l
547 if len(m.Config) > 0 {
548 for _, e := range m.Config {
549 l = e.SizeVT()
550 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
551 }
552 }
553 n += len(m.unknownFields)
554 return n
555 }