Debian Codegraph @

envoy/config/trace/v3/xray_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/trace/v3/xray.proto
6
7 package tracev3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 structpb "github.com/planetscale/vtprotobuf/types/known/structpb"
12 proto "google.golang.org/protobuf/proto"
13 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
14 )
15
16 const (
17 // Verify that this generated code is sufficiently up-to-date.
18 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
19 // Verify that runtime/protoimpl is sufficiently up-to-date.
20 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
21 )
22
23 func (m *XRayConfig_SegmentFields) MarshalVTStrict() (dAtA []byte, err error) {
24 if m == nil {
25 return nil, nil
26 }
27 size := m.SizeVT()
28 dAtA = make([]byte, size)
29 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
30 if err != nil {
31 return nil, err
32 }
33 return dAtA[:n], nil
34 }
35
36 func (m *XRayConfig_SegmentFields) MarshalToVTStrict(dAtA []byte) (int, error) {
37 size := m.SizeVT()
38 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
39 }
40
41 func (m *XRayConfig_SegmentFields) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
42 if m == nil {
43 return 0, nil
44 }
45 i := len(dAtA)
46 _ = i
47 var l int
48 _ = l
49 if m.unknownFields != nil {
50 i -= len(m.unknownFields)
51 copy(dAtA[i:], m.unknownFields)
52 }
53 if m.Aws != nil {
54 size, err := (*structpb.Struct)(m.Aws).MarshalToSizedBufferVTStrict(dAtA[:i])
55 if err != nil {
56 return 0, err
57 }
58 i -= size
59 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
60 i--
61 dAtA[i] = 0x12
62 }
63 if len(m.Origin) > 0 {
64 i -= len(m.Origin)
65 copy(dAtA[i:], m.Origin)
66 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Origin)))
67 i--
68 dAtA[i] = 0xa
69 }
70 return len(dAtA) - i, nil
71 }
72
73 func (m *XRayConfig) MarshalVTStrict() (dAtA []byte, err error) {
74 if m == nil {
75 return nil, nil
76 }
77 size := m.SizeVT()
78 dAtA = make([]byte, size)
79 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
80 if err != nil {
81 return nil, err
82 }
83 return dAtA[:n], nil
84 }
85
86 func (m *XRayConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
87 size := m.SizeVT()
88 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
89 }
90
91 func (m *XRayConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
92 if m == nil {
93 return 0, nil
94 }
95 i := len(dAtA)
96 _ = i
97 var l int
98 _ = l
99 if m.unknownFields != nil {
100 i -= len(m.unknownFields)
101 copy(dAtA[i:], m.unknownFields)
102 }
103 if m.SegmentFields != nil {
104 size, err := m.SegmentFields.MarshalToSizedBufferVTStrict(dAtA[:i])
105 if err != nil {
106 return 0, err
107 }
108 i -= size
109 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
110 i--
111 dAtA[i] = 0x22
112 }
113 if m.SamplingRuleManifest != nil {
114 if vtmsg, ok := interface{}(m.SamplingRuleManifest).(interface {
115 MarshalToSizedBufferVTStrict([]byte) (int, error)
116 }); ok {
117 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
118 if err != nil {
119 return 0, err
120 }
121 i -= size
122 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
123 } else {
124 encoded, err := proto.Marshal(m.SamplingRuleManifest)
125 if err != nil {
126 return 0, err
127 }
128 i -= len(encoded)
129 copy(dAtA[i:], encoded)
130 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
131 }
132 i--
133 dAtA[i] = 0x1a
134 }
135 if len(m.SegmentName) > 0 {
136 i -= len(m.SegmentName)
137 copy(dAtA[i:], m.SegmentName)
138 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SegmentName)))
139 i--
140 dAtA[i] = 0x12
141 }
142 if m.DaemonEndpoint != nil {
143 if vtmsg, ok := interface{}(m.DaemonEndpoint).(interface {
144 MarshalToSizedBufferVTStrict([]byte) (int, error)
145 }); ok {
146 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
147 if err != nil {
148 return 0, err
149 }
150 i -= size
151 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
152 } else {
153 encoded, err := proto.Marshal(m.DaemonEndpoint)
154 if err != nil {
155 return 0, err
156 }
157 i -= len(encoded)
158 copy(dAtA[i:], encoded)
159 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
160 }
161 i--
162 dAtA[i] = 0xa
163 }
164 return len(dAtA) - i, nil
165 }
166
167 func (m *XRayConfig_SegmentFields) SizeVT() (n int) {
168 if m == nil {
169 return 0
170 }
171 var l int
172 _ = l
173 l = len(m.Origin)
174 if l > 0 {
175 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
176 }
177 if m.Aws != nil {
178 l = (*structpb.Struct)(m.Aws).SizeVT()
179 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
180 }
181 n += len(m.unknownFields)
182 return n
183 }
184
185 func (m *XRayConfig) SizeVT() (n int) {
186 if m == nil {
187 return 0
188 }
189 var l int
190 _ = l
191 if m.DaemonEndpoint != nil {
192 if size, ok := interface{}(m.DaemonEndpoint).(interface {
193 SizeVT() int
194 }); ok {
195 l = size.SizeVT()
196 } else {
197 l = proto.Size(m.DaemonEndpoint)
198 }
199 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
200 }
201 l = len(m.SegmentName)
202 if l > 0 {
203 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
204 }
205 if m.SamplingRuleManifest != nil {
206 if size, ok := interface{}(m.SamplingRuleManifest).(interface {
207 SizeVT() int
208 }); ok {
209 l = size.SizeVT()
210 } else {
211 l = proto.Size(m.SamplingRuleManifest)
212 }
213 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
214 }
215 if m.SegmentFields != nil {
216 l = m.SegmentFields.SizeVT()
217 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
218 }
219 n += len(m.unknownFields)
220 return n
221 }