Debian Codegraph @

envoy/extensions/access_loggers/stream/v3/stream_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/access_loggers/stream/v3/stream.proto
6
7 package streamv3
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 *StdoutAccessLog) 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 *StdoutAccessLog) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *StdoutAccessLog) 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 msg, ok := m.AccessLogFormat.(*StdoutAccessLog_LogFormat); ok {
53 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
54 if err != nil {
55 return 0, err
56 }
57 i -= size
58 }
59 return len(dAtA) - i, nil
60 }
61
62 func (m *StdoutAccessLog_LogFormat) MarshalToVTStrict(dAtA []byte) (int, error) {
63 size := m.SizeVT()
64 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
65 }
66
67 func (m *StdoutAccessLog_LogFormat) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
68 i := len(dAtA)
69 if m.LogFormat != nil {
70 if vtmsg, ok := interface{}(m.LogFormat).(interface {
71 MarshalToSizedBufferVTStrict([]byte) (int, error)
72 }); ok {
73 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
74 if err != nil {
75 return 0, err
76 }
77 i -= size
78 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
79 } else {
80 encoded, err := proto.Marshal(m.LogFormat)
81 if err != nil {
82 return 0, err
83 }
84 i -= len(encoded)
85 copy(dAtA[i:], encoded)
86 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
87 }
88 i--
89 dAtA[i] = 0xa
90 } else {
91 i = protohelpers.EncodeVarint(dAtA, i, 0)
92 i--
93 dAtA[i] = 0xa
94 }
95 return len(dAtA) - i, nil
96 }
97 func (m *StderrAccessLog) MarshalVTStrict() (dAtA []byte, err error) {
98 if m == nil {
99 return nil, nil
100 }
101 size := m.SizeVT()
102 dAtA = make([]byte, size)
103 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
104 if err != nil {
105 return nil, err
106 }
107 return dAtA[:n], nil
108 }
109
110 func (m *StderrAccessLog) MarshalToVTStrict(dAtA []byte) (int, error) {
111 size := m.SizeVT()
112 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
113 }
114
115 func (m *StderrAccessLog) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
116 if m == nil {
117 return 0, nil
118 }
119 i := len(dAtA)
120 _ = i
121 var l int
122 _ = l
123 if m.unknownFields != nil {
124 i -= len(m.unknownFields)
125 copy(dAtA[i:], m.unknownFields)
126 }
127 if msg, ok := m.AccessLogFormat.(*StderrAccessLog_LogFormat); ok {
128 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
129 if err != nil {
130 return 0, err
131 }
132 i -= size
133 }
134 return len(dAtA) - i, nil
135 }
136
137 func (m *StderrAccessLog_LogFormat) MarshalToVTStrict(dAtA []byte) (int, error) {
138 size := m.SizeVT()
139 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
140 }
141
142 func (m *StderrAccessLog_LogFormat) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
143 i := len(dAtA)
144 if m.LogFormat != nil {
145 if vtmsg, ok := interface{}(m.LogFormat).(interface {
146 MarshalToSizedBufferVTStrict([]byte) (int, error)
147 }); ok {
148 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
149 if err != nil {
150 return 0, err
151 }
152 i -= size
153 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
154 } else {
155 encoded, err := proto.Marshal(m.LogFormat)
156 if err != nil {
157 return 0, err
158 }
159 i -= len(encoded)
160 copy(dAtA[i:], encoded)
161 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
162 }
163 i--
164 dAtA[i] = 0xa
165 } else {
166 i = protohelpers.EncodeVarint(dAtA, i, 0)
167 i--
168 dAtA[i] = 0xa
169 }
170 return len(dAtA) - i, nil
171 }
172 func (m *StdoutAccessLog) SizeVT() (n int) {
173 if m == nil {
174 return 0
175 }
176 var l int
177 _ = l
178 if vtmsg, ok := m.AccessLogFormat.(interface{ SizeVT() int }); ok {
179 n += vtmsg.SizeVT()
180 }
181 n += len(m.unknownFields)
182 return n
183 }
184
185 func (m *StdoutAccessLog_LogFormat) SizeVT() (n int) {
186 if m == nil {
187 return 0
188 }
189 var l int
190 _ = l
191 if m.LogFormat != nil {
192 if size, ok := interface{}(m.LogFormat).(interface {
193 SizeVT() int
194 }); ok {
195 l = size.SizeVT()
196 } else {
197 l = proto.Size(m.LogFormat)
198 }
199 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
200 } else {
201 n += 2
202 }
203 return n
204 }
205 func (m *StderrAccessLog) SizeVT() (n int) {
206 if m == nil {
207 return 0
208 }
209 var l int
210 _ = l
211 if vtmsg, ok := m.AccessLogFormat.(interface{ SizeVT() int }); ok {
212 n += vtmsg.SizeVT()
213 }
214 n += len(m.unknownFields)
215 return n
216 }
217
218 func (m *StderrAccessLog_LogFormat) SizeVT() (n int) {
219 if m == nil {
220 return 0
221 }
222 var l int
223 _ = l
224 if m.LogFormat != nil {
225 if size, ok := interface{}(m.LogFormat).(interface {
226 SizeVT() int
227 }); ok {
228 l = size.SizeVT()
229 } else {
230 l = proto.Size(m.LogFormat)
231 }
232 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
233 } else {
234 n += 2
235 }
236 return n
237 }