Debian Codegraph @

envoy/config/overload/v3/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/v3/overload.proto
6
7 package overloadv3
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 proto "google.golang.org/protobuf/proto"
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 len(m.Name) > 0 {
64 i -= len(m.Name)
65 copy(dAtA[i:], m.Name)
66 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
67 i--
68 dAtA[i] = 0xa
69 }
70 return len(dAtA) - i, nil
71 }
72
73 func (m *ResourceMonitor_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
74 size := m.SizeVT()
75 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
76 }
77
78 func (m *ResourceMonitor_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
79 i := len(dAtA)
80 if m.TypedConfig != nil {
81 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
82 if err != nil {
83 return 0, err
84 }
85 i -= size
86 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
87 i--
88 dAtA[i] = 0x1a
89 } else {
90 i = protohelpers.EncodeVarint(dAtA, i, 0)
91 i--
92 dAtA[i] = 0x1a
93 }
94 return len(dAtA) - i, nil
95 }
96 func (m *ThresholdTrigger) MarshalVTStrict() (dAtA []byte, err error) {
97 if m == nil {
98 return nil, nil
99 }
100 size := m.SizeVT()
101 dAtA = make([]byte, size)
102 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
103 if err != nil {
104 return nil, err
105 }
106 return dAtA[:n], nil
107 }
108
109 func (m *ThresholdTrigger) MarshalToVTStrict(dAtA []byte) (int, error) {
110 size := m.SizeVT()
111 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
112 }
113
114 func (m *ThresholdTrigger) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
115 if m == nil {
116 return 0, nil
117 }
118 i := len(dAtA)
119 _ = i
120 var l int
121 _ = l
122 if m.unknownFields != nil {
123 i -= len(m.unknownFields)
124 copy(dAtA[i:], m.unknownFields)
125 }
126 if m.Value != 0 {
127 i -= 8
128 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
129 i--
130 dAtA[i] = 0x9
131 }
132 return len(dAtA) - i, nil
133 }
134
135 func (m *ScaledTrigger) MarshalVTStrict() (dAtA []byte, err error) {
136 if m == nil {
137 return nil, nil
138 }
139 size := m.SizeVT()
140 dAtA = make([]byte, size)
141 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
142 if err != nil {
143 return nil, err
144 }
145 return dAtA[:n], nil
146 }
147
148 func (m *ScaledTrigger) MarshalToVTStrict(dAtA []byte) (int, error) {
149 size := m.SizeVT()
150 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
151 }
152
153 func (m *ScaledTrigger) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
154 if m == nil {
155 return 0, nil
156 }
157 i := len(dAtA)
158 _ = i
159 var l int
160 _ = l
161 if m.unknownFields != nil {
162 i -= len(m.unknownFields)
163 copy(dAtA[i:], m.unknownFields)
164 }
165 if m.SaturationThreshold != 0 {
166 i -= 8
167 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.SaturationThreshold))))
168 i--
169 dAtA[i] = 0x11
170 }
171 if m.ScalingThreshold != 0 {
172 i -= 8
173 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ScalingThreshold))))
174 i--
175 dAtA[i] = 0x9
176 }
177 return len(dAtA) - i, nil
178 }
179
180 func (m *Trigger) MarshalVTStrict() (dAtA []byte, err error) {
181 if m == nil {
182 return nil, nil
183 }
184 size := m.SizeVT()
185 dAtA = make([]byte, size)
186 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
187 if err != nil {
188 return nil, err
189 }
190 return dAtA[:n], nil
191 }
192
193 func (m *Trigger) MarshalToVTStrict(dAtA []byte) (int, error) {
194 size := m.SizeVT()
195 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
196 }
197
198 func (m *Trigger) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
199 if m == nil {
200 return 0, nil
201 }
202 i := len(dAtA)
203 _ = i
204 var l int
205 _ = l
206 if m.unknownFields != nil {
207 i -= len(m.unknownFields)
208 copy(dAtA[i:], m.unknownFields)
209 }
210 if msg, ok := m.TriggerOneof.(*Trigger_Scaled); ok {
211 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
212 if err != nil {
213 return 0, err
214 }
215 i -= size
216 }
217 if msg, ok := m.TriggerOneof.(*Trigger_Threshold); ok {
218 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
219 if err != nil {
220 return 0, err
221 }
222 i -= size
223 }
224 if len(m.Name) > 0 {
225 i -= len(m.Name)
226 copy(dAtA[i:], m.Name)
227 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
228 i--
229 dAtA[i] = 0xa
230 }
231 return len(dAtA) - i, nil
232 }
233
234 func (m *Trigger_Threshold) MarshalToVTStrict(dAtA []byte) (int, error) {
235 size := m.SizeVT()
236 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
237 }
238
239 func (m *Trigger_Threshold) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
240 i := len(dAtA)
241 if m.Threshold != nil {
242 size, err := m.Threshold.MarshalToSizedBufferVTStrict(dAtA[:i])
243 if err != nil {
244 return 0, err
245 }
246 i -= size
247 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
248 i--
249 dAtA[i] = 0x12
250 } else {
251 i = protohelpers.EncodeVarint(dAtA, i, 0)
252 i--
253 dAtA[i] = 0x12
254 }
255 return len(dAtA) - i, nil
256 }
257 func (m *Trigger_Scaled) MarshalToVTStrict(dAtA []byte) (int, error) {
258 size := m.SizeVT()
259 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
260 }
261
262 func (m *Trigger_Scaled) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
263 i := len(dAtA)
264 if m.Scaled != nil {
265 size, err := m.Scaled.MarshalToSizedBufferVTStrict(dAtA[:i])
266 if err != nil {
267 return 0, err
268 }
269 i -= size
270 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
271 i--
272 dAtA[i] = 0x1a
273 } else {
274 i = protohelpers.EncodeVarint(dAtA, i, 0)
275 i--
276 dAtA[i] = 0x1a
277 }
278 return len(dAtA) - i, nil
279 }
280 func (m *ScaleTimersOverloadActionConfig_ScaleTimer) MarshalVTStrict() (dAtA []byte, err error) {
281 if m == nil {
282 return nil, nil
283 }
284 size := m.SizeVT()
285 dAtA = make([]byte, size)
286 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
287 if err != nil {
288 return nil, err
289 }
290 return dAtA[:n], nil
291 }
292
293 func (m *ScaleTimersOverloadActionConfig_ScaleTimer) MarshalToVTStrict(dAtA []byte) (int, error) {
294 size := m.SizeVT()
295 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
296 }
297
298 func (m *ScaleTimersOverloadActionConfig_ScaleTimer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
299 if m == nil {
300 return 0, nil
301 }
302 i := len(dAtA)
303 _ = i
304 var l int
305 _ = l
306 if m.unknownFields != nil {
307 i -= len(m.unknownFields)
308 copy(dAtA[i:], m.unknownFields)
309 }
310 if msg, ok := m.OverloadAdjust.(*ScaleTimersOverloadActionConfig_ScaleTimer_MinScale); ok {
311 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
312 if err != nil {
313 return 0, err
314 }
315 i -= size
316 }
317 if msg, ok := m.OverloadAdjust.(*ScaleTimersOverloadActionConfig_ScaleTimer_MinTimeout); ok {
318 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
319 if err != nil {
320 return 0, err
321 }
322 i -= size
323 }
324 if m.Timer != 0 {
325 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Timer))
326 i--
327 dAtA[i] = 0x8
328 }
329 return len(dAtA) - i, nil
330 }
331
332 func (m *ScaleTimersOverloadActionConfig_ScaleTimer_MinTimeout) MarshalToVTStrict(dAtA []byte) (int, error) {
333 size := m.SizeVT()
334 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
335 }
336
337 func (m *ScaleTimersOverloadActionConfig_ScaleTimer_MinTimeout) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
338 i := len(dAtA)
339 if m.MinTimeout != nil {
340 size, err := (*durationpb.Duration)(m.MinTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
341 if err != nil {
342 return 0, err
343 }
344 i -= size
345 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
346 i--
347 dAtA[i] = 0x12
348 } else {
349 i = protohelpers.EncodeVarint(dAtA, i, 0)
350 i--
351 dAtA[i] = 0x12
352 }
353 return len(dAtA) - i, nil
354 }
355 func (m *ScaleTimersOverloadActionConfig_ScaleTimer_MinScale) MarshalToVTStrict(dAtA []byte) (int, error) {
356 size := m.SizeVT()
357 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
358 }
359
360 func (m *ScaleTimersOverloadActionConfig_ScaleTimer_MinScale) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
361 i := len(dAtA)
362 if m.MinScale != nil {
363 if vtmsg, ok := interface{}(m.MinScale).(interface {
364 MarshalToSizedBufferVTStrict([]byte) (int, error)
365 }); ok {
366 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
367 if err != nil {
368 return 0, err
369 }
370 i -= size
371 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
372 } else {
373 encoded, err := proto.Marshal(m.MinScale)
374 if err != nil {
375 return 0, err
376 }
377 i -= len(encoded)
378 copy(dAtA[i:], encoded)
379 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
380 }
381 i--
382 dAtA[i] = 0x1a
383 } else {
384 i = protohelpers.EncodeVarint(dAtA, i, 0)
385 i--
386 dAtA[i] = 0x1a
387 }
388 return len(dAtA) - i, nil
389 }
390 func (m *ScaleTimersOverloadActionConfig) MarshalVTStrict() (dAtA []byte, err error) {
391 if m == nil {
392 return nil, nil
393 }
394 size := m.SizeVT()
395 dAtA = make([]byte, size)
396 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
397 if err != nil {
398 return nil, err
399 }
400 return dAtA[:n], nil
401 }
402
403 func (m *ScaleTimersOverloadActionConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
404 size := m.SizeVT()
405 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
406 }
407
408 func (m *ScaleTimersOverloadActionConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
409 if m == nil {
410 return 0, nil
411 }
412 i := len(dAtA)
413 _ = i
414 var l int
415 _ = l
416 if m.unknownFields != nil {
417 i -= len(m.unknownFields)
418 copy(dAtA[i:], m.unknownFields)
419 }
420 if len(m.TimerScaleFactors) > 0 {
421 for iNdEx := len(m.TimerScaleFactors) - 1; iNdEx >= 0; iNdEx-- {
422 size, err := m.TimerScaleFactors[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
423 if err != nil {
424 return 0, err
425 }
426 i -= size
427 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
428 i--
429 dAtA[i] = 0xa
430 }
431 }
432 return len(dAtA) - i, nil
433 }
434
435 func (m *OverloadAction) MarshalVTStrict() (dAtA []byte, err error) {
436 if m == nil {
437 return nil, nil
438 }
439 size := m.SizeVT()
440 dAtA = make([]byte, size)
441 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
442 if err != nil {
443 return nil, err
444 }
445 return dAtA[:n], nil
446 }
447
448 func (m *OverloadAction) MarshalToVTStrict(dAtA []byte) (int, error) {
449 size := m.SizeVT()
450 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
451 }
452
453 func (m *OverloadAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
454 if m == nil {
455 return 0, nil
456 }
457 i := len(dAtA)
458 _ = i
459 var l int
460 _ = l
461 if m.unknownFields != nil {
462 i -= len(m.unknownFields)
463 copy(dAtA[i:], m.unknownFields)
464 }
465 if m.TypedConfig != nil {
466 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
467 if err != nil {
468 return 0, err
469 }
470 i -= size
471 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
472 i--
473 dAtA[i] = 0x1a
474 }
475 if len(m.Triggers) > 0 {
476 for iNdEx := len(m.Triggers) - 1; iNdEx >= 0; iNdEx-- {
477 size, err := m.Triggers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
478 if err != nil {
479 return 0, err
480 }
481 i -= size
482 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
483 i--
484 dAtA[i] = 0x12
485 }
486 }
487 if len(m.Name) > 0 {
488 i -= len(m.Name)
489 copy(dAtA[i:], m.Name)
490 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
491 i--
492 dAtA[i] = 0xa
493 }
494 return len(dAtA) - i, nil
495 }
496
497 func (m *LoadShedPoint) MarshalVTStrict() (dAtA []byte, err error) {
498 if m == nil {
499 return nil, nil
500 }
501 size := m.SizeVT()
502 dAtA = make([]byte, size)
503 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
504 if err != nil {
505 return nil, err
506 }
507 return dAtA[:n], nil
508 }
509
510 func (m *LoadShedPoint) MarshalToVTStrict(dAtA []byte) (int, error) {
511 size := m.SizeVT()
512 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
513 }
514
515 func (m *LoadShedPoint) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
516 if m == nil {
517 return 0, nil
518 }
519 i := len(dAtA)
520 _ = i
521 var l int
522 _ = l
523 if m.unknownFields != nil {
524 i -= len(m.unknownFields)
525 copy(dAtA[i:], m.unknownFields)
526 }
527 if len(m.Triggers) > 0 {
528 for iNdEx := len(m.Triggers) - 1; iNdEx >= 0; iNdEx-- {
529 size, err := m.Triggers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
530 if err != nil {
531 return 0, err
532 }
533 i -= size
534 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
535 i--
536 dAtA[i] = 0x12
537 }
538 }
539 if len(m.Name) > 0 {
540 i -= len(m.Name)
541 copy(dAtA[i:], m.Name)
542 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
543 i--
544 dAtA[i] = 0xa
545 }
546 return len(dAtA) - i, nil
547 }
548
549 func (m *BufferFactoryConfig) MarshalVTStrict() (dAtA []byte, err error) {
550 if m == nil {
551 return nil, nil
552 }
553 size := m.SizeVT()
554 dAtA = make([]byte, size)
555 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
556 if err != nil {
557 return nil, err
558 }
559 return dAtA[:n], nil
560 }
561
562 func (m *BufferFactoryConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
563 size := m.SizeVT()
564 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
565 }
566
567 func (m *BufferFactoryConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
568 if m == nil {
569 return 0, nil
570 }
571 i := len(dAtA)
572 _ = i
573 var l int
574 _ = l
575 if m.unknownFields != nil {
576 i -= len(m.unknownFields)
577 copy(dAtA[i:], m.unknownFields)
578 }
579 if m.MinimumAccountToTrackPowerOfTwo != 0 {
580 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MinimumAccountToTrackPowerOfTwo))
581 i--
582 dAtA[i] = 0x8
583 }
584 return len(dAtA) - i, nil
585 }
586
587 func (m *OverloadManager) MarshalVTStrict() (dAtA []byte, err error) {
588 if m == nil {
589 return nil, nil
590 }
591 size := m.SizeVT()
592 dAtA = make([]byte, size)
593 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
594 if err != nil {
595 return nil, err
596 }
597 return dAtA[:n], nil
598 }
599
600 func (m *OverloadManager) MarshalToVTStrict(dAtA []byte) (int, error) {
601 size := m.SizeVT()
602 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
603 }
604
605 func (m *OverloadManager) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
606 if m == nil {
607 return 0, nil
608 }
609 i := len(dAtA)
610 _ = i
611 var l int
612 _ = l
613 if m.unknownFields != nil {
614 i -= len(m.unknownFields)
615 copy(dAtA[i:], m.unknownFields)
616 }
617 if len(m.LoadshedPoints) > 0 {
618 for iNdEx := len(m.LoadshedPoints) - 1; iNdEx >= 0; iNdEx-- {
619 size, err := m.LoadshedPoints[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
620 if err != nil {
621 return 0, err
622 }
623 i -= size
624 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
625 i--
626 dAtA[i] = 0x2a
627 }
628 }
629 if m.BufferFactoryConfig != nil {
630 size, err := m.BufferFactoryConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
631 if err != nil {
632 return 0, err
633 }
634 i -= size
635 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
636 i--
637 dAtA[i] = 0x22
638 }
639 if len(m.Actions) > 0 {
640 for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
641 size, err := m.Actions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
642 if err != nil {
643 return 0, err
644 }
645 i -= size
646 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
647 i--
648 dAtA[i] = 0x1a
649 }
650 }
651 if len(m.ResourceMonitors) > 0 {
652 for iNdEx := len(m.ResourceMonitors) - 1; iNdEx >= 0; iNdEx-- {
653 size, err := m.ResourceMonitors[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
654 if err != nil {
655 return 0, err
656 }
657 i -= size
658 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
659 i--
660 dAtA[i] = 0x12
661 }
662 }
663 if m.RefreshInterval != nil {
664 size, err := (*durationpb.Duration)(m.RefreshInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
665 if err != nil {
666 return 0, err
667 }
668 i -= size
669 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
670 i--
671 dAtA[i] = 0xa
672 }
673 return len(dAtA) - i, nil
674 }
675
676 func (m *ResourceMonitor) SizeVT() (n int) {
677 if m == nil {
678 return 0
679 }
680 var l int
681 _ = l
682 l = len(m.Name)
683 if l > 0 {
684 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
685 }
686 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
687 n += vtmsg.SizeVT()
688 }
689 n += len(m.unknownFields)
690 return n
691 }
692
693 func (m *ResourceMonitor_TypedConfig) SizeVT() (n int) {
694 if m == nil {
695 return 0
696 }
697 var l int
698 _ = l
699 if m.TypedConfig != nil {
700 l = (*anypb.Any)(m.TypedConfig).SizeVT()
701 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
702 } else {
703 n += 2
704 }
705 return n
706 }
707 func (m *ThresholdTrigger) SizeVT() (n int) {
708 if m == nil {
709 return 0
710 }
711 var l int
712 _ = l
713 if m.Value != 0 {
714 n += 9
715 }
716 n += len(m.unknownFields)
717 return n
718 }
719
720 func (m *ScaledTrigger) SizeVT() (n int) {
721 if m == nil {
722 return 0
723 }
724 var l int
725 _ = l
726 if m.ScalingThreshold != 0 {
727 n += 9
728 }
729 if m.SaturationThreshold != 0 {
730 n += 9
731 }
732 n += len(m.unknownFields)
733 return n
734 }
735
736 func (m *Trigger) SizeVT() (n int) {
737 if m == nil {
738 return 0
739 }
740 var l int
741 _ = l
742 l = len(m.Name)
743 if l > 0 {
744 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
745 }
746 if vtmsg, ok := m.TriggerOneof.(interface{ SizeVT() int }); ok {
747 n += vtmsg.SizeVT()
748 }
749 n += len(m.unknownFields)
750 return n
751 }
752
753 func (m *Trigger_Threshold) SizeVT() (n int) {
754 if m == nil {
755 return 0
756 }
757 var l int
758 _ = l
759 if m.Threshold != nil {
760 l = m.Threshold.SizeVT()
761 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
762 } else {
763 n += 2
764 }
765 return n
766 }
767 func (m *Trigger_Scaled) SizeVT() (n int) {
768 if m == nil {
769 return 0
770 }
771 var l int
772 _ = l
773 if m.Scaled != nil {
774 l = m.Scaled.SizeVT()
775 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
776 } else {
777 n += 2
778 }
779 return n
780 }
781 func (m *ScaleTimersOverloadActionConfig_ScaleTimer) SizeVT() (n int) {
782 if m == nil {
783 return 0
784 }
785 var l int
786 _ = l
787 if m.Timer != 0 {
788 n += 1 + protohelpers.SizeOfVarint(uint64(m.Timer))
789 }
790 if vtmsg, ok := m.OverloadAdjust.(interface{ SizeVT() int }); ok {
791 n += vtmsg.SizeVT()
792 }
793 n += len(m.unknownFields)
794 return n
795 }
796
797 func (m *ScaleTimersOverloadActionConfig_ScaleTimer_MinTimeout) SizeVT() (n int) {
798 if m == nil {
799 return 0
800 }
801 var l int
802 _ = l
803 if m.MinTimeout != nil {
804 l = (*durationpb.Duration)(m.MinTimeout).SizeVT()
805 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
806 } else {
807 n += 2
808 }
809 return n
810 }
811 func (m *ScaleTimersOverloadActionConfig_ScaleTimer_MinScale) SizeVT() (n int) {
812 if m == nil {
813 return 0
814 }
815 var l int
816 _ = l
817 if m.MinScale != nil {
818 if size, ok := interface{}(m.MinScale).(interface {
819 SizeVT() int
820 }); ok {
821 l = size.SizeVT()
822 } else {
823 l = proto.Size(m.MinScale)
824 }
825 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
826 } else {
827 n += 2
828 }
829 return n
830 }
831 func (m *ScaleTimersOverloadActionConfig) SizeVT() (n int) {
832 if m == nil {
833 return 0
834 }
835 var l int
836 _ = l
837 if len(m.TimerScaleFactors) > 0 {
838 for _, e := range m.TimerScaleFactors {
839 l = e.SizeVT()
840 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
841 }
842 }
843 n += len(m.unknownFields)
844 return n
845 }
846
847 func (m *OverloadAction) SizeVT() (n int) {
848 if m == nil {
849 return 0
850 }
851 var l int
852 _ = l
853 l = len(m.Name)
854 if l > 0 {
855 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
856 }
857 if len(m.Triggers) > 0 {
858 for _, e := range m.Triggers {
859 l = e.SizeVT()
860 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
861 }
862 }
863 if m.TypedConfig != nil {
864 l = (*anypb.Any)(m.TypedConfig).SizeVT()
865 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
866 }
867 n += len(m.unknownFields)
868 return n
869 }
870
871 func (m *LoadShedPoint) SizeVT() (n int) {
872 if m == nil {
873 return 0
874 }
875 var l int
876 _ = l
877 l = len(m.Name)
878 if l > 0 {
879 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
880 }
881 if len(m.Triggers) > 0 {
882 for _, e := range m.Triggers {
883 l = e.SizeVT()
884 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
885 }
886 }
887 n += len(m.unknownFields)
888 return n
889 }
890
891 func (m *BufferFactoryConfig) SizeVT() (n int) {
892 if m == nil {
893 return 0
894 }
895 var l int
896 _ = l
897 if m.MinimumAccountToTrackPowerOfTwo != 0 {
898 n += 1 + protohelpers.SizeOfVarint(uint64(m.MinimumAccountToTrackPowerOfTwo))
899 }
900 n += len(m.unknownFields)
901 return n
902 }
903
904 func (m *OverloadManager) SizeVT() (n int) {
905 if m == nil {
906 return 0
907 }
908 var l int
909 _ = l
910 if m.RefreshInterval != nil {
911 l = (*durationpb.Duration)(m.RefreshInterval).SizeVT()
912 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
913 }
914 if len(m.ResourceMonitors) > 0 {
915 for _, e := range m.ResourceMonitors {
916 l = e.SizeVT()
917 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
918 }
919 }
920 if len(m.Actions) > 0 {
921 for _, e := range m.Actions {
922 l = e.SizeVT()
923 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
924 }
925 }
926 if m.BufferFactoryConfig != nil {
927 l = m.BufferFactoryConfig.SizeVT()
928 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
929 }
930 if len(m.LoadshedPoints) > 0 {
931 for _, e := range m.LoadshedPoints {
932 l = e.SizeVT()
933 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
934 }
935 }
936 n += len(m.unknownFields)
937 return n
938 }