Debian Codegraph @

envoy/extensions/common/ratelimit/v3/ratelimit_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/extensions/common/ratelimit/v3/ratelimit.proto
6
7 package ratelimitv3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
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 *RateLimitDescriptor_Entry) 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 *RateLimitDescriptor_Entry) MarshalToVTStrict(dAtA []byte) (int, error) {
37 size := m.SizeVT()
38 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
39 }
40
41 func (m *RateLimitDescriptor_Entry) 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 len(m.Value) > 0 {
54 i -= len(m.Value)
55 copy(dAtA[i:], m.Value)
56 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))
57 i--
58 dAtA[i] = 0x12
59 }
60 if len(m.Key) > 0 {
61 i -= len(m.Key)
62 copy(dAtA[i:], m.Key)
63 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
64 i--
65 dAtA[i] = 0xa
66 }
67 return len(dAtA) - i, nil
68 }
69
70 func (m *RateLimitDescriptor_RateLimitOverride) MarshalVTStrict() (dAtA []byte, err error) {
71 if m == nil {
72 return nil, nil
73 }
74 size := m.SizeVT()
75 dAtA = make([]byte, size)
76 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
77 if err != nil {
78 return nil, err
79 }
80 return dAtA[:n], nil
81 }
82
83 func (m *RateLimitDescriptor_RateLimitOverride) MarshalToVTStrict(dAtA []byte) (int, error) {
84 size := m.SizeVT()
85 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
86 }
87
88 func (m *RateLimitDescriptor_RateLimitOverride) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
89 if m == nil {
90 return 0, nil
91 }
92 i := len(dAtA)
93 _ = i
94 var l int
95 _ = l
96 if m.unknownFields != nil {
97 i -= len(m.unknownFields)
98 copy(dAtA[i:], m.unknownFields)
99 }
100 if m.Unit != 0 {
101 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Unit))
102 i--
103 dAtA[i] = 0x10
104 }
105 if m.RequestsPerUnit != 0 {
106 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequestsPerUnit))
107 i--
108 dAtA[i] = 0x8
109 }
110 return len(dAtA) - i, nil
111 }
112
113 func (m *RateLimitDescriptor) MarshalVTStrict() (dAtA []byte, err error) {
114 if m == nil {
115 return nil, nil
116 }
117 size := m.SizeVT()
118 dAtA = make([]byte, size)
119 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
120 if err != nil {
121 return nil, err
122 }
123 return dAtA[:n], nil
124 }
125
126 func (m *RateLimitDescriptor) MarshalToVTStrict(dAtA []byte) (int, error) {
127 size := m.SizeVT()
128 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
129 }
130
131 func (m *RateLimitDescriptor) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
132 if m == nil {
133 return 0, nil
134 }
135 i := len(dAtA)
136 _ = i
137 var l int
138 _ = l
139 if m.unknownFields != nil {
140 i -= len(m.unknownFields)
141 copy(dAtA[i:], m.unknownFields)
142 }
143 if m.HitsAddend != nil {
144 size, err := (*wrapperspb.UInt64Value)(m.HitsAddend).MarshalToSizedBufferVTStrict(dAtA[:i])
145 if err != nil {
146 return 0, err
147 }
148 i -= size
149 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
150 i--
151 dAtA[i] = 0x1a
152 }
153 if m.Limit != nil {
154 size, err := m.Limit.MarshalToSizedBufferVTStrict(dAtA[:i])
155 if err != nil {
156 return 0, err
157 }
158 i -= size
159 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
160 i--
161 dAtA[i] = 0x12
162 }
163 if len(m.Entries) > 0 {
164 for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
165 size, err := m.Entries[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
166 if err != nil {
167 return 0, err
168 }
169 i -= size
170 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
171 i--
172 dAtA[i] = 0xa
173 }
174 }
175 return len(dAtA) - i, nil
176 }
177
178 func (m *LocalRateLimitDescriptor) MarshalVTStrict() (dAtA []byte, err error) {
179 if m == nil {
180 return nil, nil
181 }
182 size := m.SizeVT()
183 dAtA = make([]byte, size)
184 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
185 if err != nil {
186 return nil, err
187 }
188 return dAtA[:n], nil
189 }
190
191 func (m *LocalRateLimitDescriptor) MarshalToVTStrict(dAtA []byte) (int, error) {
192 size := m.SizeVT()
193 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
194 }
195
196 func (m *LocalRateLimitDescriptor) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
197 if m == nil {
198 return 0, nil
199 }
200 i := len(dAtA)
201 _ = i
202 var l int
203 _ = l
204 if m.unknownFields != nil {
205 i -= len(m.unknownFields)
206 copy(dAtA[i:], m.unknownFields)
207 }
208 if m.TokenBucket != nil {
209 if vtmsg, ok := interface{}(m.TokenBucket).(interface {
210 MarshalToSizedBufferVTStrict([]byte) (int, error)
211 }); ok {
212 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
213 if err != nil {
214 return 0, err
215 }
216 i -= size
217 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
218 } else {
219 encoded, err := proto.Marshal(m.TokenBucket)
220 if err != nil {
221 return 0, err
222 }
223 i -= len(encoded)
224 copy(dAtA[i:], encoded)
225 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
226 }
227 i--
228 dAtA[i] = 0x12
229 }
230 if len(m.Entries) > 0 {
231 for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
232 size, err := m.Entries[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
233 if err != nil {
234 return 0, err
235 }
236 i -= size
237 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
238 i--
239 dAtA[i] = 0xa
240 }
241 }
242 return len(dAtA) - i, nil
243 }
244
245 func (m *LocalClusterRateLimit) MarshalVTStrict() (dAtA []byte, err error) {
246 if m == nil {
247 return nil, nil
248 }
249 size := m.SizeVT()
250 dAtA = make([]byte, size)
251 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
252 if err != nil {
253 return nil, err
254 }
255 return dAtA[:n], nil
256 }
257
258 func (m *LocalClusterRateLimit) MarshalToVTStrict(dAtA []byte) (int, error) {
259 size := m.SizeVT()
260 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
261 }
262
263 func (m *LocalClusterRateLimit) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
264 if m == nil {
265 return 0, nil
266 }
267 i := len(dAtA)
268 _ = i
269 var l int
270 _ = l
271 if m.unknownFields != nil {
272 i -= len(m.unknownFields)
273 copy(dAtA[i:], m.unknownFields)
274 }
275 return len(dAtA) - i, nil
276 }
277
278 func (m *RateLimitDescriptor_Entry) SizeVT() (n int) {
279 if m == nil {
280 return 0
281 }
282 var l int
283 _ = l
284 l = len(m.Key)
285 if l > 0 {
286 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
287 }
288 l = len(m.Value)
289 if l > 0 {
290 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
291 }
292 n += len(m.unknownFields)
293 return n
294 }
295
296 func (m *RateLimitDescriptor_RateLimitOverride) SizeVT() (n int) {
297 if m == nil {
298 return 0
299 }
300 var l int
301 _ = l
302 if m.RequestsPerUnit != 0 {
303 n += 1 + protohelpers.SizeOfVarint(uint64(m.RequestsPerUnit))
304 }
305 if m.Unit != 0 {
306 n += 1 + protohelpers.SizeOfVarint(uint64(m.Unit))
307 }
308 n += len(m.unknownFields)
309 return n
310 }
311
312 func (m *RateLimitDescriptor) SizeVT() (n int) {
313 if m == nil {
314 return 0
315 }
316 var l int
317 _ = l
318 if len(m.Entries) > 0 {
319 for _, e := range m.Entries {
320 l = e.SizeVT()
321 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
322 }
323 }
324 if m.Limit != nil {
325 l = m.Limit.SizeVT()
326 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
327 }
328 if m.HitsAddend != nil {
329 l = (*wrapperspb.UInt64Value)(m.HitsAddend).SizeVT()
330 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
331 }
332 n += len(m.unknownFields)
333 return n
334 }
335
336 func (m *LocalRateLimitDescriptor) SizeVT() (n int) {
337 if m == nil {
338 return 0
339 }
340 var l int
341 _ = l
342 if len(m.Entries) > 0 {
343 for _, e := range m.Entries {
344 l = e.SizeVT()
345 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
346 }
347 }
348 if m.TokenBucket != nil {
349 if size, ok := interface{}(m.TokenBucket).(interface {
350 SizeVT() int
351 }); ok {
352 l = size.SizeVT()
353 } else {
354 l = proto.Size(m.TokenBucket)
355 }
356 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
357 }
358 n += len(m.unknownFields)
359 return n
360 }
361
362 func (m *LocalClusterRateLimit) SizeVT() (n int) {
363 if m == nil {
364 return 0
365 }
366 var l int
367 _ = l
368 n += len(m.unknownFields)
369 return n
370 }