Debian Codegraph @

envoy/config/endpoint/v3/endpoint_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/endpoint/v3/endpoint.proto
6
7 package endpointv3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
12 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
13 proto "google.golang.org/protobuf/proto"
14 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
15 )
16
17 const (
18 // Verify that this generated code is sufficiently up-to-date.
19 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
20 // Verify that runtime/protoimpl is sufficiently up-to-date.
21 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
22 )
23
24 func (m *ClusterLoadAssignment_Policy_DropOverload) MarshalVTStrict() (dAtA []byte, err error) {
25 if m == nil {
26 return nil, nil
27 }
28 size := m.SizeVT()
29 dAtA = make([]byte, size)
30 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
31 if err != nil {
32 return nil, err
33 }
34 return dAtA[:n], nil
35 }
36
37 func (m *ClusterLoadAssignment_Policy_DropOverload) MarshalToVTStrict(dAtA []byte) (int, error) {
38 size := m.SizeVT()
39 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
40 }
41
42 func (m *ClusterLoadAssignment_Policy_DropOverload) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
43 if m == nil {
44 return 0, nil
45 }
46 i := len(dAtA)
47 _ = i
48 var l int
49 _ = l
50 if m.unknownFields != nil {
51 i -= len(m.unknownFields)
52 copy(dAtA[i:], m.unknownFields)
53 }
54 if m.DropPercentage != nil {
55 if vtmsg, ok := interface{}(m.DropPercentage).(interface {
56 MarshalToSizedBufferVTStrict([]byte) (int, error)
57 }); ok {
58 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
59 if err != nil {
60 return 0, err
61 }
62 i -= size
63 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
64 } else {
65 encoded, err := proto.Marshal(m.DropPercentage)
66 if err != nil {
67 return 0, err
68 }
69 i -= len(encoded)
70 copy(dAtA[i:], encoded)
71 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
72 }
73 i--
74 dAtA[i] = 0x12
75 }
76 if len(m.Category) > 0 {
77 i -= len(m.Category)
78 copy(dAtA[i:], m.Category)
79 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Category)))
80 i--
81 dAtA[i] = 0xa
82 }
83 return len(dAtA) - i, nil
84 }
85
86 func (m *ClusterLoadAssignment_Policy) MarshalVTStrict() (dAtA []byte, err error) {
87 if m == nil {
88 return nil, nil
89 }
90 size := m.SizeVT()
91 dAtA = make([]byte, size)
92 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
93 if err != nil {
94 return nil, err
95 }
96 return dAtA[:n], nil
97 }
98
99 func (m *ClusterLoadAssignment_Policy) MarshalToVTStrict(dAtA []byte) (int, error) {
100 size := m.SizeVT()
101 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
102 }
103
104 func (m *ClusterLoadAssignment_Policy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
105 if m == nil {
106 return 0, nil
107 }
108 i := len(dAtA)
109 _ = i
110 var l int
111 _ = l
112 if m.unknownFields != nil {
113 i -= len(m.unknownFields)
114 copy(dAtA[i:], m.unknownFields)
115 }
116 if m.WeightedPriorityHealth {
117 i--
118 if m.WeightedPriorityHealth {
119 dAtA[i] = 1
120 } else {
121 dAtA[i] = 0
122 }
123 i--
124 dAtA[i] = 0x30
125 }
126 if m.EndpointStaleAfter != nil {
127 size, err := (*durationpb.Duration)(m.EndpointStaleAfter).MarshalToSizedBufferVTStrict(dAtA[:i])
128 if err != nil {
129 return 0, err
130 }
131 i -= size
132 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
133 i--
134 dAtA[i] = 0x22
135 }
136 if m.OverprovisioningFactor != nil {
137 size, err := (*wrapperspb.UInt32Value)(m.OverprovisioningFactor).MarshalToSizedBufferVTStrict(dAtA[:i])
138 if err != nil {
139 return 0, err
140 }
141 i -= size
142 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
143 i--
144 dAtA[i] = 0x1a
145 }
146 if len(m.DropOverloads) > 0 {
147 for iNdEx := len(m.DropOverloads) - 1; iNdEx >= 0; iNdEx-- {
148 size, err := m.DropOverloads[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
149 if err != nil {
150 return 0, err
151 }
152 i -= size
153 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
154 i--
155 dAtA[i] = 0x12
156 }
157 }
158 return len(dAtA) - i, nil
159 }
160
161 func (m *ClusterLoadAssignment) MarshalVTStrict() (dAtA []byte, err error) {
162 if m == nil {
163 return nil, nil
164 }
165 size := m.SizeVT()
166 dAtA = make([]byte, size)
167 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
168 if err != nil {
169 return nil, err
170 }
171 return dAtA[:n], nil
172 }
173
174 func (m *ClusterLoadAssignment) MarshalToVTStrict(dAtA []byte) (int, error) {
175 size := m.SizeVT()
176 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
177 }
178
179 func (m *ClusterLoadAssignment) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
180 if m == nil {
181 return 0, nil
182 }
183 i := len(dAtA)
184 _ = i
185 var l int
186 _ = l
187 if m.unknownFields != nil {
188 i -= len(m.unknownFields)
189 copy(dAtA[i:], m.unknownFields)
190 }
191 if len(m.NamedEndpoints) > 0 {
192 for k := range m.NamedEndpoints {
193 v := m.NamedEndpoints[k]
194 baseI := i
195 size, err := v.MarshalToSizedBufferVTStrict(dAtA[:i])
196 if err != nil {
197 return 0, err
198 }
199 i -= size
200 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
201 i--
202 dAtA[i] = 0x12
203 i -= len(k)
204 copy(dAtA[i:], k)
205 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
206 i--
207 dAtA[i] = 0xa
208 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
209 i--
210 dAtA[i] = 0x2a
211 }
212 }
213 if m.Policy != nil {
214 size, err := m.Policy.MarshalToSizedBufferVTStrict(dAtA[:i])
215 if err != nil {
216 return 0, err
217 }
218 i -= size
219 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
220 i--
221 dAtA[i] = 0x22
222 }
223 if len(m.Endpoints) > 0 {
224 for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- {
225 size, err := m.Endpoints[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
226 if err != nil {
227 return 0, err
228 }
229 i -= size
230 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
231 i--
232 dAtA[i] = 0x12
233 }
234 }
235 if len(m.ClusterName) > 0 {
236 i -= len(m.ClusterName)
237 copy(dAtA[i:], m.ClusterName)
238 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterName)))
239 i--
240 dAtA[i] = 0xa
241 }
242 return len(dAtA) - i, nil
243 }
244
245 func (m *ClusterLoadAssignment_Policy_DropOverload) SizeVT() (n int) {
246 if m == nil {
247 return 0
248 }
249 var l int
250 _ = l
251 l = len(m.Category)
252 if l > 0 {
253 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
254 }
255 if m.DropPercentage != nil {
256 if size, ok := interface{}(m.DropPercentage).(interface {
257 SizeVT() int
258 }); ok {
259 l = size.SizeVT()
260 } else {
261 l = proto.Size(m.DropPercentage)
262 }
263 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
264 }
265 n += len(m.unknownFields)
266 return n
267 }
268
269 func (m *ClusterLoadAssignment_Policy) SizeVT() (n int) {
270 if m == nil {
271 return 0
272 }
273 var l int
274 _ = l
275 if len(m.DropOverloads) > 0 {
276 for _, e := range m.DropOverloads {
277 l = e.SizeVT()
278 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
279 }
280 }
281 if m.OverprovisioningFactor != nil {
282 l = (*wrapperspb.UInt32Value)(m.OverprovisioningFactor).SizeVT()
283 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
284 }
285 if m.EndpointStaleAfter != nil {
286 l = (*durationpb.Duration)(m.EndpointStaleAfter).SizeVT()
287 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
288 }
289 if m.WeightedPriorityHealth {
290 n += 2
291 }
292 n += len(m.unknownFields)
293 return n
294 }
295
296 func (m *ClusterLoadAssignment) SizeVT() (n int) {
297 if m == nil {
298 return 0
299 }
300 var l int
301 _ = l
302 l = len(m.ClusterName)
303 if l > 0 {
304 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
305 }
306 if len(m.Endpoints) > 0 {
307 for _, e := range m.Endpoints {
308 l = e.SizeVT()
309 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
310 }
311 }
312 if m.Policy != nil {
313 l = m.Policy.SizeVT()
314 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
315 }
316 if len(m.NamedEndpoints) > 0 {
317 for k, v := range m.NamedEndpoints {
318 _ = k
319 _ = v
320 l = 0
321 if v != nil {
322 l = v.SizeVT()
323 }
324 l += 1 + protohelpers.SizeOfVarint(uint64(l))
325 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
326 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
327 }
328 }
329 n += len(m.unknownFields)
330 return n
331 }