Debian Codegraph @

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