Debian Codegraph @

envoy/service/accesslog/v3/als_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/accesslog/v3/als.proto
6
7 package accesslogv3
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 *StreamAccessLogsResponse) 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 *StreamAccessLogsResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *StreamAccessLogsResponse) 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 return len(dAtA) - i, nil
53 }
54
55 func (m *StreamAccessLogsMessage_Identifier) MarshalVTStrict() (dAtA []byte, err error) {
56 if m == nil {
57 return nil, nil
58 }
59 size := m.SizeVT()
60 dAtA = make([]byte, size)
61 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
62 if err != nil {
63 return nil, err
64 }
65 return dAtA[:n], nil
66 }
67
68 func (m *StreamAccessLogsMessage_Identifier) MarshalToVTStrict(dAtA []byte) (int, error) {
69 size := m.SizeVT()
70 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
71 }
72
73 func (m *StreamAccessLogsMessage_Identifier) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
74 if m == nil {
75 return 0, nil
76 }
77 i := len(dAtA)
78 _ = i
79 var l int
80 _ = l
81 if m.unknownFields != nil {
82 i -= len(m.unknownFields)
83 copy(dAtA[i:], m.unknownFields)
84 }
85 if len(m.LogName) > 0 {
86 i -= len(m.LogName)
87 copy(dAtA[i:], m.LogName)
88 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogName)))
89 i--
90 dAtA[i] = 0x12
91 }
92 if m.Node != nil {
93 if vtmsg, ok := interface{}(m.Node).(interface {
94 MarshalToSizedBufferVTStrict([]byte) (int, error)
95 }); ok {
96 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
97 if err != nil {
98 return 0, err
99 }
100 i -= size
101 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
102 } else {
103 encoded, err := proto.Marshal(m.Node)
104 if err != nil {
105 return 0, err
106 }
107 i -= len(encoded)
108 copy(dAtA[i:], encoded)
109 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
110 }
111 i--
112 dAtA[i] = 0xa
113 }
114 return len(dAtA) - i, nil
115 }
116
117 func (m *StreamAccessLogsMessage_HTTPAccessLogEntries) MarshalVTStrict() (dAtA []byte, err error) {
118 if m == nil {
119 return nil, nil
120 }
121 size := m.SizeVT()
122 dAtA = make([]byte, size)
123 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
124 if err != nil {
125 return nil, err
126 }
127 return dAtA[:n], nil
128 }
129
130 func (m *StreamAccessLogsMessage_HTTPAccessLogEntries) MarshalToVTStrict(dAtA []byte) (int, error) {
131 size := m.SizeVT()
132 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
133 }
134
135 func (m *StreamAccessLogsMessage_HTTPAccessLogEntries) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
136 if m == nil {
137 return 0, nil
138 }
139 i := len(dAtA)
140 _ = i
141 var l int
142 _ = l
143 if m.unknownFields != nil {
144 i -= len(m.unknownFields)
145 copy(dAtA[i:], m.unknownFields)
146 }
147 if len(m.LogEntry) > 0 {
148 for iNdEx := len(m.LogEntry) - 1; iNdEx >= 0; iNdEx-- {
149 if vtmsg, ok := interface{}(m.LogEntry[iNdEx]).(interface {
150 MarshalToSizedBufferVTStrict([]byte) (int, error)
151 }); ok {
152 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
153 if err != nil {
154 return 0, err
155 }
156 i -= size
157 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
158 } else {
159 encoded, err := proto.Marshal(m.LogEntry[iNdEx])
160 if err != nil {
161 return 0, err
162 }
163 i -= len(encoded)
164 copy(dAtA[i:], encoded)
165 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
166 }
167 i--
168 dAtA[i] = 0xa
169 }
170 }
171 return len(dAtA) - i, nil
172 }
173
174 func (m *StreamAccessLogsMessage_TCPAccessLogEntries) MarshalVTStrict() (dAtA []byte, err error) {
175 if m == nil {
176 return nil, nil
177 }
178 size := m.SizeVT()
179 dAtA = make([]byte, size)
180 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
181 if err != nil {
182 return nil, err
183 }
184 return dAtA[:n], nil
185 }
186
187 func (m *StreamAccessLogsMessage_TCPAccessLogEntries) MarshalToVTStrict(dAtA []byte) (int, error) {
188 size := m.SizeVT()
189 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
190 }
191
192 func (m *StreamAccessLogsMessage_TCPAccessLogEntries) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
193 if m == nil {
194 return 0, nil
195 }
196 i := len(dAtA)
197 _ = i
198 var l int
199 _ = l
200 if m.unknownFields != nil {
201 i -= len(m.unknownFields)
202 copy(dAtA[i:], m.unknownFields)
203 }
204 if len(m.LogEntry) > 0 {
205 for iNdEx := len(m.LogEntry) - 1; iNdEx >= 0; iNdEx-- {
206 if vtmsg, ok := interface{}(m.LogEntry[iNdEx]).(interface {
207 MarshalToSizedBufferVTStrict([]byte) (int, error)
208 }); ok {
209 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
210 if err != nil {
211 return 0, err
212 }
213 i -= size
214 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
215 } else {
216 encoded, err := proto.Marshal(m.LogEntry[iNdEx])
217 if err != nil {
218 return 0, err
219 }
220 i -= len(encoded)
221 copy(dAtA[i:], encoded)
222 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
223 }
224 i--
225 dAtA[i] = 0xa
226 }
227 }
228 return len(dAtA) - i, nil
229 }
230
231 func (m *StreamAccessLogsMessage) MarshalVTStrict() (dAtA []byte, err error) {
232 if m == nil {
233 return nil, nil
234 }
235 size := m.SizeVT()
236 dAtA = make([]byte, size)
237 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
238 if err != nil {
239 return nil, err
240 }
241 return dAtA[:n], nil
242 }
243
244 func (m *StreamAccessLogsMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
245 size := m.SizeVT()
246 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
247 }
248
249 func (m *StreamAccessLogsMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
250 if m == nil {
251 return 0, nil
252 }
253 i := len(dAtA)
254 _ = i
255 var l int
256 _ = l
257 if m.unknownFields != nil {
258 i -= len(m.unknownFields)
259 copy(dAtA[i:], m.unknownFields)
260 }
261 if msg, ok := m.LogEntries.(*StreamAccessLogsMessage_TcpLogs); ok {
262 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
263 if err != nil {
264 return 0, err
265 }
266 i -= size
267 }
268 if msg, ok := m.LogEntries.(*StreamAccessLogsMessage_HttpLogs); ok {
269 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
270 if err != nil {
271 return 0, err
272 }
273 i -= size
274 }
275 if m.Identifier != nil {
276 size, err := m.Identifier.MarshalToSizedBufferVTStrict(dAtA[:i])
277 if err != nil {
278 return 0, err
279 }
280 i -= size
281 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
282 i--
283 dAtA[i] = 0xa
284 }
285 return len(dAtA) - i, nil
286 }
287
288 func (m *StreamAccessLogsMessage_HttpLogs) MarshalToVTStrict(dAtA []byte) (int, error) {
289 size := m.SizeVT()
290 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
291 }
292
293 func (m *StreamAccessLogsMessage_HttpLogs) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
294 i := len(dAtA)
295 if m.HttpLogs != nil {
296 size, err := m.HttpLogs.MarshalToSizedBufferVTStrict(dAtA[:i])
297 if err != nil {
298 return 0, err
299 }
300 i -= size
301 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
302 i--
303 dAtA[i] = 0x12
304 } else {
305 i = protohelpers.EncodeVarint(dAtA, i, 0)
306 i--
307 dAtA[i] = 0x12
308 }
309 return len(dAtA) - i, nil
310 }
311 func (m *StreamAccessLogsMessage_TcpLogs) MarshalToVTStrict(dAtA []byte) (int, error) {
312 size := m.SizeVT()
313 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
314 }
315
316 func (m *StreamAccessLogsMessage_TcpLogs) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
317 i := len(dAtA)
318 if m.TcpLogs != nil {
319 size, err := m.TcpLogs.MarshalToSizedBufferVTStrict(dAtA[:i])
320 if err != nil {
321 return 0, err
322 }
323 i -= size
324 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
325 i--
326 dAtA[i] = 0x1a
327 } else {
328 i = protohelpers.EncodeVarint(dAtA, i, 0)
329 i--
330 dAtA[i] = 0x1a
331 }
332 return len(dAtA) - i, nil
333 }
334 func (m *StreamAccessLogsResponse) SizeVT() (n int) {
335 if m == nil {
336 return 0
337 }
338 var l int
339 _ = l
340 n += len(m.unknownFields)
341 return n
342 }
343
344 func (m *StreamAccessLogsMessage_Identifier) SizeVT() (n int) {
345 if m == nil {
346 return 0
347 }
348 var l int
349 _ = l
350 if m.Node != nil {
351 if size, ok := interface{}(m.Node).(interface {
352 SizeVT() int
353 }); ok {
354 l = size.SizeVT()
355 } else {
356 l = proto.Size(m.Node)
357 }
358 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
359 }
360 l = len(m.LogName)
361 if l > 0 {
362 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
363 }
364 n += len(m.unknownFields)
365 return n
366 }
367
368 func (m *StreamAccessLogsMessage_HTTPAccessLogEntries) SizeVT() (n int) {
369 if m == nil {
370 return 0
371 }
372 var l int
373 _ = l
374 if len(m.LogEntry) > 0 {
375 for _, e := range m.LogEntry {
376 if size, ok := interface{}(e).(interface {
377 SizeVT() int
378 }); ok {
379 l = size.SizeVT()
380 } else {
381 l = proto.Size(e)
382 }
383 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
384 }
385 }
386 n += len(m.unknownFields)
387 return n
388 }
389
390 func (m *StreamAccessLogsMessage_TCPAccessLogEntries) SizeVT() (n int) {
391 if m == nil {
392 return 0
393 }
394 var l int
395 _ = l
396 if len(m.LogEntry) > 0 {
397 for _, e := range m.LogEntry {
398 if size, ok := interface{}(e).(interface {
399 SizeVT() int
400 }); ok {
401 l = size.SizeVT()
402 } else {
403 l = proto.Size(e)
404 }
405 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
406 }
407 }
408 n += len(m.unknownFields)
409 return n
410 }
411
412 func (m *StreamAccessLogsMessage) SizeVT() (n int) {
413 if m == nil {
414 return 0
415 }
416 var l int
417 _ = l
418 if m.Identifier != nil {
419 l = m.Identifier.SizeVT()
420 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
421 }
422 if vtmsg, ok := m.LogEntries.(interface{ SizeVT() int }); ok {
423 n += vtmsg.SizeVT()
424 }
425 n += len(m.unknownFields)
426 return n
427 }
428
429 func (m *StreamAccessLogsMessage_HttpLogs) SizeVT() (n int) {
430 if m == nil {
431 return 0
432 }
433 var l int
434 _ = l
435 if m.HttpLogs != nil {
436 l = m.HttpLogs.SizeVT()
437 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
438 } else {
439 n += 2
440 }
441 return n
442 }
443 func (m *StreamAccessLogsMessage_TcpLogs) SizeVT() (n int) {
444 if m == nil {
445 return 0
446 }
447 var l int
448 _ = l
449 if m.TcpLogs != nil {
450 l = m.TcpLogs.SizeVT()
451 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
452 } else {
453 n += 2
454 }
455 return n
456 }