Debian Codegraph @

envoy/service/ratelimit/v2/rls_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/service/ratelimit/v2/rls.proto
6
7 package ratelimitv2
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 proto "google.golang.org/protobuf/proto"
12 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
13 )
14
15 const (
16 // Verify that this generated code is sufficiently up-to-date.
17 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
18 // Verify that runtime/protoimpl is sufficiently up-to-date.
19 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
20 )
21
22 func (m *RateLimitRequest) MarshalVTStrict() (dAtA []byte, err error) {
23 if m == nil {
24 return nil, nil
25 }
26 size := m.SizeVT()
27 dAtA = make([]byte, size)
28 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
29 if err != nil {
30 return nil, err
31 }
32 return dAtA[:n], nil
33 }
34
35 func (m *RateLimitRequest) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *RateLimitRequest) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
41 if m == nil {
42 return 0, nil
43 }
44 i := len(dAtA)
45 _ = i
46 var l int
47 _ = l
48 if m.unknownFields != nil {
49 i -= len(m.unknownFields)
50 copy(dAtA[i:], m.unknownFields)
51 }
52 if m.HitsAddend != 0 {
53 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HitsAddend))
54 i--
55 dAtA[i] = 0x18
56 }
57 if len(m.Descriptors) > 0 {
58 for iNdEx := len(m.Descriptors) - 1; iNdEx >= 0; iNdEx-- {
59 if vtmsg, ok := interface{}(m.Descriptors[iNdEx]).(interface {
60 MarshalToSizedBufferVTStrict([]byte) (int, error)
61 }); ok {
62 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
63 if err != nil {
64 return 0, err
65 }
66 i -= size
67 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
68 } else {
69 encoded, err := proto.Marshal(m.Descriptors[iNdEx])
70 if err != nil {
71 return 0, err
72 }
73 i -= len(encoded)
74 copy(dAtA[i:], encoded)
75 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
76 }
77 i--
78 dAtA[i] = 0x12
79 }
80 }
81 if len(m.Domain) > 0 {
82 i -= len(m.Domain)
83 copy(dAtA[i:], m.Domain)
84 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Domain)))
85 i--
86 dAtA[i] = 0xa
87 }
88 return len(dAtA) - i, nil
89 }
90
91 func (m *RateLimitResponse_RateLimit) MarshalVTStrict() (dAtA []byte, err error) {
92 if m == nil {
93 return nil, nil
94 }
95 size := m.SizeVT()
96 dAtA = make([]byte, size)
97 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
98 if err != nil {
99 return nil, err
100 }
101 return dAtA[:n], nil
102 }
103
104 func (m *RateLimitResponse_RateLimit) MarshalToVTStrict(dAtA []byte) (int, error) {
105 size := m.SizeVT()
106 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
107 }
108
109 func (m *RateLimitResponse_RateLimit) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
110 if m == nil {
111 return 0, nil
112 }
113 i := len(dAtA)
114 _ = i
115 var l int
116 _ = l
117 if m.unknownFields != nil {
118 i -= len(m.unknownFields)
119 copy(dAtA[i:], m.unknownFields)
120 }
121 if len(m.Name) > 0 {
122 i -= len(m.Name)
123 copy(dAtA[i:], m.Name)
124 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
125 i--
126 dAtA[i] = 0x1a
127 }
128 if m.Unit != 0 {
129 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Unit))
130 i--
131 dAtA[i] = 0x10
132 }
133 if m.RequestsPerUnit != 0 {
134 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequestsPerUnit))
135 i--
136 dAtA[i] = 0x8
137 }
138 return len(dAtA) - i, nil
139 }
140
141 func (m *RateLimitResponse_DescriptorStatus) MarshalVTStrict() (dAtA []byte, err error) {
142 if m == nil {
143 return nil, nil
144 }
145 size := m.SizeVT()
146 dAtA = make([]byte, size)
147 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
148 if err != nil {
149 return nil, err
150 }
151 return dAtA[:n], nil
152 }
153
154 func (m *RateLimitResponse_DescriptorStatus) MarshalToVTStrict(dAtA []byte) (int, error) {
155 size := m.SizeVT()
156 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
157 }
158
159 func (m *RateLimitResponse_DescriptorStatus) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
160 if m == nil {
161 return 0, nil
162 }
163 i := len(dAtA)
164 _ = i
165 var l int
166 _ = l
167 if m.unknownFields != nil {
168 i -= len(m.unknownFields)
169 copy(dAtA[i:], m.unknownFields)
170 }
171 if m.LimitRemaining != 0 {
172 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LimitRemaining))
173 i--
174 dAtA[i] = 0x18
175 }
176 if m.CurrentLimit != nil {
177 size, err := m.CurrentLimit.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] = 0x12
185 }
186 if m.Code != 0 {
187 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Code))
188 i--
189 dAtA[i] = 0x8
190 }
191 return len(dAtA) - i, nil
192 }
193
194 func (m *RateLimitResponse) MarshalVTStrict() (dAtA []byte, err error) {
195 if m == nil {
196 return nil, nil
197 }
198 size := m.SizeVT()
199 dAtA = make([]byte, size)
200 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
201 if err != nil {
202 return nil, err
203 }
204 return dAtA[:n], nil
205 }
206
207 func (m *RateLimitResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
208 size := m.SizeVT()
209 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
210 }
211
212 func (m *RateLimitResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
213 if m == nil {
214 return 0, nil
215 }
216 i := len(dAtA)
217 _ = i
218 var l int
219 _ = l
220 if m.unknownFields != nil {
221 i -= len(m.unknownFields)
222 copy(dAtA[i:], m.unknownFields)
223 }
224 if len(m.RequestHeadersToAdd) > 0 {
225 for iNdEx := len(m.RequestHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
226 if vtmsg, ok := interface{}(m.RequestHeadersToAdd[iNdEx]).(interface {
227 MarshalToSizedBufferVTStrict([]byte) (int, error)
228 }); ok {
229 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
230 if err != nil {
231 return 0, err
232 }
233 i -= size
234 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
235 } else {
236 encoded, err := proto.Marshal(m.RequestHeadersToAdd[iNdEx])
237 if err != nil {
238 return 0, err
239 }
240 i -= len(encoded)
241 copy(dAtA[i:], encoded)
242 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
243 }
244 i--
245 dAtA[i] = 0x22
246 }
247 }
248 if len(m.Headers) > 0 {
249 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
250 if vtmsg, ok := interface{}(m.Headers[iNdEx]).(interface {
251 MarshalToSizedBufferVTStrict([]byte) (int, error)
252 }); ok {
253 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
254 if err != nil {
255 return 0, err
256 }
257 i -= size
258 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
259 } else {
260 encoded, err := proto.Marshal(m.Headers[iNdEx])
261 if err != nil {
262 return 0, err
263 }
264 i -= len(encoded)
265 copy(dAtA[i:], encoded)
266 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
267 }
268 i--
269 dAtA[i] = 0x1a
270 }
271 }
272 if len(m.Statuses) > 0 {
273 for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- {
274 size, err := m.Statuses[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
275 if err != nil {
276 return 0, err
277 }
278 i -= size
279 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
280 i--
281 dAtA[i] = 0x12
282 }
283 }
284 if m.OverallCode != 0 {
285 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.OverallCode))
286 i--
287 dAtA[i] = 0x8
288 }
289 return len(dAtA) - i, nil
290 }
291
292 func (m *RateLimitRequest) SizeVT() (n int) {
293 if m == nil {
294 return 0
295 }
296 var l int
297 _ = l
298 l = len(m.Domain)
299 if l > 0 {
300 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
301 }
302 if len(m.Descriptors) > 0 {
303 for _, e := range m.Descriptors {
304 if size, ok := interface{}(e).(interface {
305 SizeVT() int
306 }); ok {
307 l = size.SizeVT()
308 } else {
309 l = proto.Size(e)
310 }
311 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
312 }
313 }
314 if m.HitsAddend != 0 {
315 n += 1 + protohelpers.SizeOfVarint(uint64(m.HitsAddend))
316 }
317 n += len(m.unknownFields)
318 return n
319 }
320
321 func (m *RateLimitResponse_RateLimit) SizeVT() (n int) {
322 if m == nil {
323 return 0
324 }
325 var l int
326 _ = l
327 if m.RequestsPerUnit != 0 {
328 n += 1 + protohelpers.SizeOfVarint(uint64(m.RequestsPerUnit))
329 }
330 if m.Unit != 0 {
331 n += 1 + protohelpers.SizeOfVarint(uint64(m.Unit))
332 }
333 l = len(m.Name)
334 if l > 0 {
335 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
336 }
337 n += len(m.unknownFields)
338 return n
339 }
340
341 func (m *RateLimitResponse_DescriptorStatus) SizeVT() (n int) {
342 if m == nil {
343 return 0
344 }
345 var l int
346 _ = l
347 if m.Code != 0 {
348 n += 1 + protohelpers.SizeOfVarint(uint64(m.Code))
349 }
350 if m.CurrentLimit != nil {
351 l = m.CurrentLimit.SizeVT()
352 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
353 }
354 if m.LimitRemaining != 0 {
355 n += 1 + protohelpers.SizeOfVarint(uint64(m.LimitRemaining))
356 }
357 n += len(m.unknownFields)
358 return n
359 }
360
361 func (m *RateLimitResponse) SizeVT() (n int) {
362 if m == nil {
363 return 0
364 }
365 var l int
366 _ = l
367 if m.OverallCode != 0 {
368 n += 1 + protohelpers.SizeOfVarint(uint64(m.OverallCode))
369 }
370 if len(m.Statuses) > 0 {
371 for _, e := range m.Statuses {
372 l = e.SizeVT()
373 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
374 }
375 }
376 if len(m.Headers) > 0 {
377 for _, e := range m.Headers {
378 if size, ok := interface{}(e).(interface {
379 SizeVT() int
380 }); ok {
381 l = size.SizeVT()
382 } else {
383 l = proto.Size(e)
384 }
385 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
386 }
387 }
388 if len(m.RequestHeadersToAdd) > 0 {
389 for _, e := range m.RequestHeadersToAdd {
390 if size, ok := interface{}(e).(interface {
391 SizeVT() int
392 }); ok {
393 l = size.SizeVT()
394 } else {
395 l = proto.Size(e)
396 }
397 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
398 }
399 }
400 n += len(m.unknownFields)
401 return n
402 }