1
2
3
4 package v2alpha
5
6 import (
7 "bytes"
8 "errors"
9 "fmt"
10 "net"
11 "net/mail"
12 "net/url"
13 "regexp"
14 "sort"
15 "strings"
16 "time"
17 "unicode/utf8"
18
19 "google.golang.org/protobuf/types/known/anypb"
20 )
21
22
23 var (
24 _ = bytes.MinRead
25 _ = errors.New("")
26 _ = fmt.Print
27 _ = utf8.UTFMax
28 _ = (*regexp.Regexp)(nil)
29 _ = (*strings.Reader)(nil)
30 _ = net.IPv4len
31 _ = time.Duration(0)
32 _ = (*url.URL)(nil)
33 _ = (*mail.Address)(nil)
34 _ = anypb.Any{}
35 _ = sort.Sort
36 )
37
38
39
40
41 func (m *TraceWrapper) Validate() error {
42 return m.validate(false)
43 }
44
45
46
47
48
49 func (m *TraceWrapper) ValidateAll() error {
50 return m.validate(true)
51 }
52
53 func (m *TraceWrapper) validate(all bool) error {
54 if m == nil {
55 return nil
56 }
57
58 var errors []error
59
60 oneofTracePresent := false
61 switch v := m.Trace.(type) {
62 case *TraceWrapper_HttpBufferedTrace:
63 if v == nil {
64 err := TraceWrapperValidationError{
65 field: "Trace",
66 reason: "oneof value cannot be a typed-nil",
67 }
68 if !all {
69 return err
70 }
71 errors = append(errors, err)
72 }
73 oneofTracePresent = true
74
75 if all {
76 switch v := interface{}(m.GetHttpBufferedTrace()).(type) {
77 case interface{ ValidateAll() error }:
78 if err := v.ValidateAll(); err != nil {
79 errors = append(errors, TraceWrapperValidationError{
80 field: "HttpBufferedTrace",
81 reason: "embedded message failed validation",
82 cause: err,
83 })
84 }
85 case interface{ Validate() error }:
86 if err := v.Validate(); err != nil {
87 errors = append(errors, TraceWrapperValidationError{
88 field: "HttpBufferedTrace",
89 reason: "embedded message failed validation",
90 cause: err,
91 })
92 }
93 }
94 } else if v, ok := interface{}(m.GetHttpBufferedTrace()).(interface{ Validate() error }); ok {
95 if err := v.Validate(); err != nil {
96 return TraceWrapperValidationError{
97 field: "HttpBufferedTrace",
98 reason: "embedded message failed validation",
99 cause: err,
100 }
101 }
102 }
103
104 case *TraceWrapper_HttpStreamedTraceSegment:
105 if v == nil {
106 err := TraceWrapperValidationError{
107 field: "Trace",
108 reason: "oneof value cannot be a typed-nil",
109 }
110 if !all {
111 return err
112 }
113 errors = append(errors, err)
114 }
115 oneofTracePresent = true
116
117 if all {
118 switch v := interface{}(m.GetHttpStreamedTraceSegment()).(type) {
119 case interface{ ValidateAll() error }:
120 if err := v.ValidateAll(); err != nil {
121 errors = append(errors, TraceWrapperValidationError{
122 field: "HttpStreamedTraceSegment",
123 reason: "embedded message failed validation",
124 cause: err,
125 })
126 }
127 case interface{ Validate() error }:
128 if err := v.Validate(); err != nil {
129 errors = append(errors, TraceWrapperValidationError{
130 field: "HttpStreamedTraceSegment",
131 reason: "embedded message failed validation",
132 cause: err,
133 })
134 }
135 }
136 } else if v, ok := interface{}(m.GetHttpStreamedTraceSegment()).(interface{ Validate() error }); ok {
137 if err := v.Validate(); err != nil {
138 return TraceWrapperValidationError{
139 field: "HttpStreamedTraceSegment",
140 reason: "embedded message failed validation",
141 cause: err,
142 }
143 }
144 }
145
146 case *TraceWrapper_SocketBufferedTrace:
147 if v == nil {
148 err := TraceWrapperValidationError{
149 field: "Trace",
150 reason: "oneof value cannot be a typed-nil",
151 }
152 if !all {
153 return err
154 }
155 errors = append(errors, err)
156 }
157 oneofTracePresent = true
158
159 if all {
160 switch v := interface{}(m.GetSocketBufferedTrace()).(type) {
161 case interface{ ValidateAll() error }:
162 if err := v.ValidateAll(); err != nil {
163 errors = append(errors, TraceWrapperValidationError{
164 field: "SocketBufferedTrace",
165 reason: "embedded message failed validation",
166 cause: err,
167 })
168 }
169 case interface{ Validate() error }:
170 if err := v.Validate(); err != nil {
171 errors = append(errors, TraceWrapperValidationError{
172 field: "SocketBufferedTrace",
173 reason: "embedded message failed validation",
174 cause: err,
175 })
176 }
177 }
178 } else if v, ok := interface{}(m.GetSocketBufferedTrace()).(interface{ Validate() error }); ok {
179 if err := v.Validate(); err != nil {
180 return TraceWrapperValidationError{
181 field: "SocketBufferedTrace",
182 reason: "embedded message failed validation",
183 cause: err,
184 }
185 }
186 }
187
188 case *TraceWrapper_SocketStreamedTraceSegment:
189 if v == nil {
190 err := TraceWrapperValidationError{
191 field: "Trace",
192 reason: "oneof value cannot be a typed-nil",
193 }
194 if !all {
195 return err
196 }
197 errors = append(errors, err)
198 }
199 oneofTracePresent = true
200
201 if all {
202 switch v := interface{}(m.GetSocketStreamedTraceSegment()).(type) {
203 case interface{ ValidateAll() error }:
204 if err := v.ValidateAll(); err != nil {
205 errors = append(errors, TraceWrapperValidationError{
206 field: "SocketStreamedTraceSegment",
207 reason: "embedded message failed validation",
208 cause: err,
209 })
210 }
211 case interface{ Validate() error }:
212 if err := v.Validate(); err != nil {
213 errors = append(errors, TraceWrapperValidationError{
214 field: "SocketStreamedTraceSegment",
215 reason: "embedded message failed validation",
216 cause: err,
217 })
218 }
219 }
220 } else if v, ok := interface{}(m.GetSocketStreamedTraceSegment()).(interface{ Validate() error }); ok {
221 if err := v.Validate(); err != nil {
222 return TraceWrapperValidationError{
223 field: "SocketStreamedTraceSegment",
224 reason: "embedded message failed validation",
225 cause: err,
226 }
227 }
228 }
229
230 default:
231 _ = v
232 }
233 if !oneofTracePresent {
234 err := TraceWrapperValidationError{
235 field: "Trace",
236 reason: "value is required",
237 }
238 if !all {
239 return err
240 }
241 errors = append(errors, err)
242 }
243
244 if len(errors) > 0 {
245 return TraceWrapperMultiError(errors)
246 }
247
248 return nil
249 }
250
251
252
253 type TraceWrapperMultiError []error
254
255
256 func (m TraceWrapperMultiError) Error() string {
257 var msgs []string
258 for _, err := range m {
259 msgs = append(msgs, err.Error())
260 }
261 return strings.Join(msgs, "; ")
262 }
263
264
265 func (m TraceWrapperMultiError) AllErrors() []error { return m }
266
267
268
269 type TraceWrapperValidationError struct {
270 field string
271 reason string
272 cause error
273 key bool
274 }
275
276
277 func (e TraceWrapperValidationError) Field() string { return e.field }
278
279
280 func (e TraceWrapperValidationError) Reason() string { return e.reason }
281
282
283 func (e TraceWrapperValidationError) Cause() error { return e.cause }
284
285
286 func (e TraceWrapperValidationError) Key() bool { return e.key }
287
288
289 func (e TraceWrapperValidationError) ErrorName() string { return "TraceWrapperValidationError" }
290
291
292 func (e TraceWrapperValidationError) Error() string {
293 cause := ""
294 if e.cause != nil {
295 cause = fmt.Sprintf(" | caused by: %v", e.cause)
296 }
297
298 key := ""
299 if e.key {
300 key = "key for "
301 }
302
303 return fmt.Sprintf(
304 "invalid %sTraceWrapper.%s: %s%s",
305 key,
306 e.field,
307 e.reason,
308 cause)
309 }
310
311 var _ error = TraceWrapperValidationError{}
312
313 var _ interface {
314 Field() string
315 Reason() string
316 Key() bool
317 Cause() error
318 ErrorName() string
319 } = TraceWrapperValidationError{}
320
View as plain text