Debian Codegraph @

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