Debian Codegraph @

envoy/config/overload/v2alpha/overload_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/overload/v2alpha/overload.proto
6
7 package v2alpha
8
9 import (
10 binary "encoding/binary"
11 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
12 anypb "github.com/planetscale/vtprotobuf/types/known/anypb"
13 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
14 structpb "github.com/planetscale/vtprotobuf/types/known/structpb"
15 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
16 math "math"
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 *ResourceMonitor) 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 *ResourceMonitor) MarshalToVTStrict(dAtA []byte) (int, error) {
40 size := m.SizeVT()
41 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
42 }
43
44 func (m *ResourceMonitor) 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 msg, ok := m.ConfigType.(*ResourceMonitor_TypedConfig); ok {
57 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
58 if err != nil {
59 return 0, err
60 }
61 i -= size
62 }
63 if msg, ok := m.ConfigType.(*ResourceMonitor_Config); ok {
64 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
65 if err != nil {
66 return 0, err
67 }
68 i -= size
69 }
70 if len(m.Name) > 0 {
71 i -= len(m.Name)
72 copy(dAtA[i:], m.Name)
73 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
74 i--
75 dAtA[i] = 0xa
76 }
77 return len(dAtA) - i, nil
78 }
79
80 func (m *ResourceMonitor_Config) MarshalToVTStrict(dAtA []byte) (int, error) {
81 size := m.SizeVT()
82 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
83 }
84
85 func (m *ResourceMonitor_Config) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
86 i := len(dAtA)
87 if m.Config != nil {
88 size, err := (*structpb.Struct)(m.Config).MarshalToSizedBufferVTStrict(dAtA[:i])
89 if err != nil {
90 return 0, err
91 }
92 i -= size
93 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
94 i--
95 dAtA[i] = 0x12
96 } else {
97 i = protohelpers.EncodeVarint(dAtA, i, 0)
98 i--
99 dAtA[i] = 0x12
100 }
101 return len(dAtA) - i, nil
102 }
103 func (m *ResourceMonitor_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
104 size := m.SizeVT()
105 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
106 }
107
108 func (m *ResourceMonitor_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
109 i := len(dAtA)
110 if m.TypedConfig != nil {
111 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
112 if err != nil {
113 return 0, err
114 }
115 i -= size
116 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
117 i--
118 dAtA[i] = 0x1a
119 } else {
120 i = protohelpers.EncodeVarint(dAtA, i, 0)
121 i--
122 dAtA[i] = 0x1a
123 }
124 return len(dAtA) - i, nil
125 }
126 func (m *ThresholdTrigger) MarshalVTStrict() (dAtA []byte, err error) {
127 if m == nil {
128 return nil, nil
129 }
130 size := m.SizeVT()
131 dAtA = make([]byte, size)
132 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
133 if err != nil {
134 return nil, err
135 }
136 return dAtA[:n], nil
137 }
138
139 func (m *ThresholdTrigger) MarshalToVTStrict(dAtA []byte) (int, error) {
140 size := m.SizeVT()
141 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
142 }
143
144 func (m *ThresholdTrigger) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
145 if m == nil {
146 return 0, nil
147 }
148 i := len(dAtA)
149 _ = i
150 var l int
151 _ = l
152 if m.unknownFields != nil {
153 i -= len(m.unknownFields)
154 copy(dAtA[i:], m.unknownFields)
155 }
156 if m.Value != 0 {
157 i -= 8
158 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
159 i--
160 dAtA[i] = 0x9
161 }
162 return len(dAtA) - i, nil
163 }
164
165 func (m *Trigger) MarshalVTStrict() (dAtA []byte, err error) {
166 if m == nil {
167 return nil, nil
168 }
169 size := m.SizeVT()
170 dAtA = make([]byte, size)
171 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
172 if err != nil {
173 return nil, err
174 }
175 return dAtA[:n], nil
176 }
177
178 func (m *Trigger) MarshalToVTStrict(dAtA []byte) (int, error) {
179 size := m.SizeVT()
180 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
181 }
182
183 func (m *Trigger) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
184 if m == nil {
185 return 0, nil
186 }
187 i := len(dAtA)
188 _ = i
189 var l int
190 _ = l
191 if m.unknownFields != nil {
192 i -= len(m.unknownFields)
193 copy(dAtA[i:], m.unknownFields)
194 }
195 if msg, ok := m.TriggerOneof.(*Trigger_Threshold); ok {
196 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
197 if err != nil {
198 return 0, err
199 }
200 i -= size
201 }
202 if len(m.Name) > 0 {
203 i -= len(m.Name)
204 copy(dAtA[i:], m.Name)
205 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
206 i--
207 dAtA[i] = 0xa
208 }
209 return len(dAtA) - i, nil
210 }
211
212 func (m *Trigger_Threshold) MarshalToVTStrict(dAtA []byte) (int, error) {
213 size := m.SizeVT()
214 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
215 }
216
217 func (m *Trigger_Threshold) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
218 i := len(dAtA)
219 if m.Threshold != nil {
220 size, err := m.Threshold.MarshalToSizedBufferVTStrict(dAtA[:i])
221 if err != nil {
222 return 0, err
223 }
224 i -= size
225 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
226 i--
227 dAtA[i] = 0x12
228 } else {
229 i = protohelpers.EncodeVarint(dAtA, i, 0)
230 i--
231 dAtA[i] = 0x12
232 }
233 return len(dAtA) - i, nil
234 }
235 func (m *OverloadAction) MarshalVTStrict() (dAtA []byte, err error) {
236 if m == nil {
237 return nil, nil
238 }
239 size := m.SizeVT()
240 dAtA = make([]byte, size)
241 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
242 if err != nil {
243 return nil, err
244 }
245 return dAtA[:n], nil
246 }
247
248 func (m *OverloadAction) MarshalToVTStrict(dAtA []byte) (int, error) {
249 size := m.SizeVT()
250 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
251 }
252
253 func (m *OverloadAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
254 if m == nil {
255 return 0, nil
256 }
257 i := len(dAtA)
258 _ = i
259 var l int
260 _ = l
261 if m.unknownFields != nil {
262 i -= len(m.unknownFields)
263 copy(dAtA[i:], m.unknownFields)
264 }
265 if len(m.Triggers) > 0 {
266 for iNdEx := len(m.Triggers) - 1; iNdEx >= 0; iNdEx-- {
267 size, err := m.Triggers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
268 if err != nil {
269 return 0, err
270 }
271 i -= size
272 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
273 i--
274 dAtA[i] = 0x12
275 }
276 }
277 if len(m.Name) > 0 {
278 i -= len(m.Name)
279 copy(dAtA[i:], m.Name)
280 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
281 i--
282 dAtA[i] = 0xa
283 }
284 return len(dAtA) - i, nil
285 }
286
287 func (m *OverloadManager) MarshalVTStrict() (dAtA []byte, err error) {
288 if m == nil {
289 return nil, nil
290 }
291 size := m.SizeVT()
292 dAtA = make([]byte, size)
293 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
294 if err != nil {
295 return nil, err
296 }
297 return dAtA[:n], nil
298 }
299
300 func (m *OverloadManager) MarshalToVTStrict(dAtA []byte) (int, error) {
301 size := m.SizeVT()
302 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
303 }
304
305 func (m *OverloadManager) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
306 if m == nil {
307 return 0, nil
308 }
309 i := len(dAtA)
310 _ = i
311 var l int
312 _ = l
313 if m.unknownFields != nil {
314 i -= len(m.unknownFields)
315 copy(dAtA[i:], m.unknownFields)
316 }
317 if len(m.Actions) > 0 {
318 for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
319 size, err := m.Actions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
320 if err != nil {
321 return 0, err
322 }
323 i -= size
324 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
325 i--
326 dAtA[i] = 0x1a
327 }
328 }
329 if len(m.ResourceMonitors) > 0 {
330 for iNdEx := len(m.ResourceMonitors) - 1; iNdEx >= 0; iNdEx-- {
331 size, err := m.ResourceMonitors[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
332 if err != nil {
333 return 0, err
334 }
335 i -= size
336 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
337 i--
338 dAtA[i] = 0x12
339 }
340 }
341 if m.RefreshInterval != nil {
342 size, err := (*durationpb.Duration)(m.RefreshInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
343 if err != nil {
344 return 0, err
345 }
346 i -= size
347 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
348 i--
349 dAtA[i] = 0xa
350 }
351 return len(dAtA) - i, nil
352 }
353
354 func (m *ResourceMonitor) SizeVT() (n int) {
355 if m == nil {
356 return 0
357 }
358 var l int
359 _ = l
360 l = len(m.Name)
361 if l > 0 {
362 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
363 }
364 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
365 n += vtmsg.SizeVT()
366 }
367 n += len(m.unknownFields)
368 return n
369 }
370
371 func (m *ResourceMonitor_Config) SizeVT() (n int) {
372 if m == nil {
373 return 0
374 }
375 var l int
376 _ = l
377 if m.Config != nil {
378 l = (*structpb.Struct)(m.Config).SizeVT()
379 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
380 } else {
381 n += 2
382 }
383 return n
384 }
385 func (m *ResourceMonitor_TypedConfig) SizeVT() (n int) {
386 if m == nil {
387 return 0
388 }
389 var l int
390 _ = l
391 if m.TypedConfig != nil {
392 l = (*anypb.Any)(m.TypedConfig).SizeVT()
393 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
394 } else {
395 n += 2
396 }
397 return n
398 }
399 func (m *ThresholdTrigger) SizeVT() (n int) {
400 if m == nil {
401 return 0
402 }
403 var l int
404 _ = l
405 if m.Value != 0 {
406 n += 9
407 }
408 n += len(m.unknownFields)
409 return n
410 }
411
412 func (m *Trigger) SizeVT() (n int) {
413 if m == nil {
414 return 0
415 }
416 var l int
417 _ = l
418 l = len(m.Name)
419 if l > 0 {
420 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
421 }
422 if vtmsg, ok := m.TriggerOneof.(interface{ SizeVT() int }); ok {
423 n += vtmsg.SizeVT()
424 }
425 n += len(m.unknownFields)
426 return n
427 }
428
429 func (m *Trigger_Threshold) SizeVT() (n int) {
430 if m == nil {
431 return 0
432 }
433 var l int
434 _ = l
435 if m.Threshold != nil {
436 l = m.Threshold.SizeVT()
437 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
438 } else {
439 n += 2
440 }
441 return n
442 }
443 func (m *OverloadAction) SizeVT() (n int) {
444 if m == nil {
445 return 0
446 }
447 var l int
448 _ = l
449 l = len(m.Name)
450 if l > 0 {
451 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
452 }
453 if len(m.Triggers) > 0 {
454 for _, e := range m.Triggers {
455 l = e.SizeVT()
456 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
457 }
458 }
459 n += len(m.unknownFields)
460 return n
461 }
462
463 func (m *OverloadManager) SizeVT() (n int) {
464 if m == nil {
465 return 0
466 }
467 var l int
468 _ = l
469 if m.RefreshInterval != nil {
470 l = (*durationpb.Duration)(m.RefreshInterval).SizeVT()
471 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
472 }
473 if len(m.ResourceMonitors) > 0 {
474 for _, e := range m.ResourceMonitors {
475 l = e.SizeVT()
476 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
477 }
478 }
479 if len(m.Actions) > 0 {
480 for _, e := range m.Actions {
481 l = e.SizeVT()
482 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
483 }
484 }
485 n += len(m.unknownFields)
486 return n
487 }