1
2
3
4
9 package examplepb
10
11 import (
12 "context"
13 "io"
14 "net/http"
15
16 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/oneofenum"
17 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/pathenum"
18 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/sub"
19 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/sub2"
20 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
21 "github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
22 "google.golang.org/grpc"
23 "google.golang.org/grpc/codes"
24 "google.golang.org/grpc/grpclog"
25 "google.golang.org/grpc/metadata"
26 "google.golang.org/grpc/status"
27 "google.golang.org/protobuf/proto"
28 "google.golang.org/protobuf/types/known/emptypb"
29 )
30
31
32 var _ codes.Code
33 var _ io.Reader
34 var _ status.Status
35 var _ = runtime.String
36 var _ = utilities.NewDoubleArray
37 var _ = metadata.Join
38
39 var (
40 filter_ABitOfEverythingService_Create_0 = &utilities.DoubleArray{Encoding: map[string]int{"float_value": 0, "double_value": 1, "int64_value": 2, "uint64_value": 3, "int32_value": 4, "fixed64_value": 5, "fixed32_value": 6, "bool_value": 7, "string_value": 8, "uint32_value": 9, "sfixed32_value": 10, "sfixed64_value": 11, "sint32_value": 12, "sint64_value": 13, "nonConventionalNameValue": 14, "enum_value": 15, "path_enum_value": 16, "nested_path_enum_value": 17, "enum_value_annotation": 18}, Base: []int{1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}
41 )
42
43 func request_ABitOfEverythingService_Create_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
44 var protoReq ABitOfEverything
45 var metadata runtime.ServerMetadata
46
47 var (
48 val string
49 e int32
50 ok bool
51 err error
52 _ = err
53 )
54
55 val, ok = pathParams["float_value"]
56 if !ok {
57 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "float_value")
58 }
59
60 protoReq.FloatValue, err = runtime.Float32(val)
61 if err != nil {
62 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "float_value", err)
63 }
64
65 val, ok = pathParams["double_value"]
66 if !ok {
67 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "double_value")
68 }
69
70 protoReq.DoubleValue, err = runtime.Float64(val)
71 if err != nil {
72 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "double_value", err)
73 }
74
75 val, ok = pathParams["int64_value"]
76 if !ok {
77 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64_value")
78 }
79
80 protoReq.Int64Value, err = runtime.Int64(val)
81 if err != nil {
82 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64_value", err)
83 }
84
85 val, ok = pathParams["uint64_value"]
86 if !ok {
87 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64_value")
88 }
89
90 protoReq.Uint64Value, err = runtime.Uint64(val)
91 if err != nil {
92 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64_value", err)
93 }
94
95 val, ok = pathParams["int32_value"]
96 if !ok {
97 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32_value")
98 }
99
100 protoReq.Int32Value, err = runtime.Int32(val)
101 if err != nil {
102 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32_value", err)
103 }
104
105 val, ok = pathParams["fixed64_value"]
106 if !ok {
107 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed64_value")
108 }
109
110 protoReq.Fixed64Value, err = runtime.Uint64(val)
111 if err != nil {
112 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed64_value", err)
113 }
114
115 val, ok = pathParams["fixed32_value"]
116 if !ok {
117 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed32_value")
118 }
119
120 protoReq.Fixed32Value, err = runtime.Uint32(val)
121 if err != nil {
122 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed32_value", err)
123 }
124
125 val, ok = pathParams["bool_value"]
126 if !ok {
127 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bool_value")
128 }
129
130 protoReq.BoolValue, err = runtime.Bool(val)
131 if err != nil {
132 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bool_value", err)
133 }
134
135 val, ok = pathParams["string_value"]
136 if !ok {
137 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
138 }
139
140 protoReq.StringValue, err = runtime.String(val)
141 if err != nil {
142 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
143 }
144
145 val, ok = pathParams["uint32_value"]
146 if !ok {
147 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32_value")
148 }
149
150 protoReq.Uint32Value, err = runtime.Uint32(val)
151 if err != nil {
152 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32_value", err)
153 }
154
155 val, ok = pathParams["sfixed32_value"]
156 if !ok {
157 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed32_value")
158 }
159
160 protoReq.Sfixed32Value, err = runtime.Int32(val)
161 if err != nil {
162 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed32_value", err)
163 }
164
165 val, ok = pathParams["sfixed64_value"]
166 if !ok {
167 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed64_value")
168 }
169
170 protoReq.Sfixed64Value, err = runtime.Int64(val)
171 if err != nil {
172 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed64_value", err)
173 }
174
175 val, ok = pathParams["sint32_value"]
176 if !ok {
177 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint32_value")
178 }
179
180 protoReq.Sint32Value, err = runtime.Int32(val)
181 if err != nil {
182 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint32_value", err)
183 }
184
185 val, ok = pathParams["sint64_value"]
186 if !ok {
187 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint64_value")
188 }
189
190 protoReq.Sint64Value, err = runtime.Int64(val)
191 if err != nil {
192 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint64_value", err)
193 }
194
195 val, ok = pathParams["nonConventionalNameValue"]
196 if !ok {
197 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nonConventionalNameValue")
198 }
199
200 protoReq.NonConventionalNameValue, err = runtime.String(val)
201 if err != nil {
202 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nonConventionalNameValue", err)
203 }
204
205 val, ok = pathParams["enum_value"]
206 if !ok {
207 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value")
208 }
209
210 e, err = runtime.Enum(val, NumericEnum_value)
211 if err != nil {
212 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value", err)
213 }
214
215 protoReq.EnumValue = NumericEnum(e)
216
217 val, ok = pathParams["path_enum_value"]
218 if !ok {
219 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_enum_value")
220 }
221
222 e, err = runtime.Enum(val, pathenum.PathEnum_value)
223 if err != nil {
224 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_enum_value", err)
225 }
226
227 protoReq.PathEnumValue = pathenum.PathEnum(e)
228
229 val, ok = pathParams["nested_path_enum_value"]
230 if !ok {
231 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nested_path_enum_value")
232 }
233
234 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
235 if err != nil {
236 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nested_path_enum_value", err)
237 }
238
239 protoReq.NestedPathEnumValue = pathenum.MessagePathEnum_NestedPathEnum(e)
240
241 val, ok = pathParams["enum_value_annotation"]
242 if !ok {
243 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value_annotation")
244 }
245
246 e, err = runtime.Enum(val, NumericEnum_value)
247 if err != nil {
248 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value_annotation", err)
249 }
250
251 protoReq.EnumValueAnnotation = NumericEnum(e)
252
253 if err := req.ParseForm(); err != nil {
254 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
255 }
256 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Create_0); err != nil {
257 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
258 }
259
260 msg, err := client.Create(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
261 return msg, metadata, err
262
263 }
264
265 func local_request_ABitOfEverythingService_Create_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
266 var protoReq ABitOfEverything
267 var metadata runtime.ServerMetadata
268
269 var (
270 val string
271 e int32
272 ok bool
273 err error
274 _ = err
275 )
276
277 val, ok = pathParams["float_value"]
278 if !ok {
279 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "float_value")
280 }
281
282 protoReq.FloatValue, err = runtime.Float32(val)
283 if err != nil {
284 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "float_value", err)
285 }
286
287 val, ok = pathParams["double_value"]
288 if !ok {
289 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "double_value")
290 }
291
292 protoReq.DoubleValue, err = runtime.Float64(val)
293 if err != nil {
294 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "double_value", err)
295 }
296
297 val, ok = pathParams["int64_value"]
298 if !ok {
299 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64_value")
300 }
301
302 protoReq.Int64Value, err = runtime.Int64(val)
303 if err != nil {
304 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64_value", err)
305 }
306
307 val, ok = pathParams["uint64_value"]
308 if !ok {
309 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64_value")
310 }
311
312 protoReq.Uint64Value, err = runtime.Uint64(val)
313 if err != nil {
314 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64_value", err)
315 }
316
317 val, ok = pathParams["int32_value"]
318 if !ok {
319 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32_value")
320 }
321
322 protoReq.Int32Value, err = runtime.Int32(val)
323 if err != nil {
324 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32_value", err)
325 }
326
327 val, ok = pathParams["fixed64_value"]
328 if !ok {
329 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed64_value")
330 }
331
332 protoReq.Fixed64Value, err = runtime.Uint64(val)
333 if err != nil {
334 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed64_value", err)
335 }
336
337 val, ok = pathParams["fixed32_value"]
338 if !ok {
339 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed32_value")
340 }
341
342 protoReq.Fixed32Value, err = runtime.Uint32(val)
343 if err != nil {
344 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed32_value", err)
345 }
346
347 val, ok = pathParams["bool_value"]
348 if !ok {
349 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bool_value")
350 }
351
352 protoReq.BoolValue, err = runtime.Bool(val)
353 if err != nil {
354 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bool_value", err)
355 }
356
357 val, ok = pathParams["string_value"]
358 if !ok {
359 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
360 }
361
362 protoReq.StringValue, err = runtime.String(val)
363 if err != nil {
364 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
365 }
366
367 val, ok = pathParams["uint32_value"]
368 if !ok {
369 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32_value")
370 }
371
372 protoReq.Uint32Value, err = runtime.Uint32(val)
373 if err != nil {
374 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32_value", err)
375 }
376
377 val, ok = pathParams["sfixed32_value"]
378 if !ok {
379 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed32_value")
380 }
381
382 protoReq.Sfixed32Value, err = runtime.Int32(val)
383 if err != nil {
384 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed32_value", err)
385 }
386
387 val, ok = pathParams["sfixed64_value"]
388 if !ok {
389 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed64_value")
390 }
391
392 protoReq.Sfixed64Value, err = runtime.Int64(val)
393 if err != nil {
394 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed64_value", err)
395 }
396
397 val, ok = pathParams["sint32_value"]
398 if !ok {
399 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint32_value")
400 }
401
402 protoReq.Sint32Value, err = runtime.Int32(val)
403 if err != nil {
404 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint32_value", err)
405 }
406
407 val, ok = pathParams["sint64_value"]
408 if !ok {
409 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint64_value")
410 }
411
412 protoReq.Sint64Value, err = runtime.Int64(val)
413 if err != nil {
414 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint64_value", err)
415 }
416
417 val, ok = pathParams["nonConventionalNameValue"]
418 if !ok {
419 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nonConventionalNameValue")
420 }
421
422 protoReq.NonConventionalNameValue, err = runtime.String(val)
423 if err != nil {
424 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nonConventionalNameValue", err)
425 }
426
427 val, ok = pathParams["enum_value"]
428 if !ok {
429 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value")
430 }
431
432 e, err = runtime.Enum(val, NumericEnum_value)
433 if err != nil {
434 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value", err)
435 }
436
437 protoReq.EnumValue = NumericEnum(e)
438
439 val, ok = pathParams["path_enum_value"]
440 if !ok {
441 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_enum_value")
442 }
443
444 e, err = runtime.Enum(val, pathenum.PathEnum_value)
445 if err != nil {
446 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_enum_value", err)
447 }
448
449 protoReq.PathEnumValue = pathenum.PathEnum(e)
450
451 val, ok = pathParams["nested_path_enum_value"]
452 if !ok {
453 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nested_path_enum_value")
454 }
455
456 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
457 if err != nil {
458 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nested_path_enum_value", err)
459 }
460
461 protoReq.NestedPathEnumValue = pathenum.MessagePathEnum_NestedPathEnum(e)
462
463 val, ok = pathParams["enum_value_annotation"]
464 if !ok {
465 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value_annotation")
466 }
467
468 e, err = runtime.Enum(val, NumericEnum_value)
469 if err != nil {
470 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value_annotation", err)
471 }
472
473 protoReq.EnumValueAnnotation = NumericEnum(e)
474
475 if err := req.ParseForm(); err != nil {
476 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
477 }
478 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Create_0); err != nil {
479 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
480 }
481
482 msg, err := server.Create(ctx, &protoReq)
483 return msg, metadata, err
484
485 }
486
487 func request_ABitOfEverythingService_CreateBody_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
488 var protoReq ABitOfEverything
489 var metadata runtime.ServerMetadata
490
491 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
492 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
493 }
494
495 msg, err := client.CreateBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
496 return msg, metadata, err
497
498 }
499
500 func local_request_ABitOfEverythingService_CreateBody_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
501 var protoReq ABitOfEverything
502 var metadata runtime.ServerMetadata
503
504 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
505 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
506 }
507
508 msg, err := server.CreateBody(ctx, &protoReq)
509 return msg, metadata, err
510
511 }
512
513 var (
514 filter_ABitOfEverythingService_CreateBook_0 = &utilities.DoubleArray{Encoding: map[string]int{"book": 0, "parent": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
515 )
516
517 func request_ABitOfEverythingService_CreateBook_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
518 var protoReq CreateBookRequest
519 var metadata runtime.ServerMetadata
520
521 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Book); err != nil && err != io.EOF {
522 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
523 }
524
525 var (
526 val string
527 ok bool
528 err error
529 _ = err
530 )
531
532 val, ok = pathParams["parent"]
533 if !ok {
534 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent")
535 }
536
537 protoReq.Parent, err = runtime.String(val)
538 if err != nil {
539 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err)
540 }
541
542 if err := req.ParseForm(); err != nil {
543 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
544 }
545 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CreateBook_0); err != nil {
546 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
547 }
548
549 msg, err := client.CreateBook(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
550 return msg, metadata, err
551
552 }
553
554 func local_request_ABitOfEverythingService_CreateBook_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
555 var protoReq CreateBookRequest
556 var metadata runtime.ServerMetadata
557
558 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Book); err != nil && err != io.EOF {
559 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
560 }
561
562 var (
563 val string
564 ok bool
565 err error
566 _ = err
567 )
568
569 val, ok = pathParams["parent"]
570 if !ok {
571 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent")
572 }
573
574 protoReq.Parent, err = runtime.String(val)
575 if err != nil {
576 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err)
577 }
578
579 if err := req.ParseForm(); err != nil {
580 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
581 }
582 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CreateBook_0); err != nil {
583 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
584 }
585
586 msg, err := server.CreateBook(ctx, &protoReq)
587 return msg, metadata, err
588
589 }
590
591 var (
592 filter_ABitOfEverythingService_UpdateBook_0 = &utilities.DoubleArray{Encoding: map[string]int{"book": 0, "name": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}}
593 )
594
595 func request_ABitOfEverythingService_UpdateBook_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
596 var protoReq UpdateBookRequest
597 var metadata runtime.ServerMetadata
598
599 newReader, berr := utilities.IOReaderFactory(req.Body)
600 if berr != nil {
601 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
602 }
603 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Book); err != nil && err != io.EOF {
604 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
605 }
606 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
607 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Book); err != nil {
608 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
609 } else {
610 protoReq.UpdateMask = fieldMask
611 }
612 }
613
614 var (
615 val string
616 ok bool
617 err error
618 _ = err
619 )
620
621 val, ok = pathParams["book.name"]
622 if !ok {
623 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "book.name")
624 }
625
626 err = runtime.PopulateFieldFromPath(&protoReq, "book.name", val)
627 if err != nil {
628 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "book.name", err)
629 }
630
631 if err := req.ParseForm(); err != nil {
632 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
633 }
634 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateBook_0); err != nil {
635 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
636 }
637
638 msg, err := client.UpdateBook(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
639 return msg, metadata, err
640
641 }
642
643 func local_request_ABitOfEverythingService_UpdateBook_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
644 var protoReq UpdateBookRequest
645 var metadata runtime.ServerMetadata
646
647 newReader, berr := utilities.IOReaderFactory(req.Body)
648 if berr != nil {
649 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
650 }
651 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Book); err != nil && err != io.EOF {
652 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
653 }
654 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
655 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Book); err != nil {
656 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
657 } else {
658 protoReq.UpdateMask = fieldMask
659 }
660 }
661
662 var (
663 val string
664 ok bool
665 err error
666 _ = err
667 )
668
669 val, ok = pathParams["book.name"]
670 if !ok {
671 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "book.name")
672 }
673
674 err = runtime.PopulateFieldFromPath(&protoReq, "book.name", val)
675 if err != nil {
676 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "book.name", err)
677 }
678
679 if err := req.ParseForm(); err != nil {
680 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
681 }
682 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateBook_0); err != nil {
683 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
684 }
685
686 msg, err := server.UpdateBook(ctx, &protoReq)
687 return msg, metadata, err
688
689 }
690
691 func request_ABitOfEverythingService_Lookup_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
692 var protoReq sub2.IdMessage
693 var metadata runtime.ServerMetadata
694
695 var (
696 val string
697 ok bool
698 err error
699 _ = err
700 )
701
702 val, ok = pathParams["uuid"]
703 if !ok {
704 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
705 }
706
707 protoReq.Uuid, err = runtime.String(val)
708 if err != nil {
709 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
710 }
711
712 msg, err := client.Lookup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
713 return msg, metadata, err
714
715 }
716
717 func local_request_ABitOfEverythingService_Lookup_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
718 var protoReq sub2.IdMessage
719 var metadata runtime.ServerMetadata
720
721 var (
722 val string
723 ok bool
724 err error
725 _ = err
726 )
727
728 val, ok = pathParams["uuid"]
729 if !ok {
730 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
731 }
732
733 protoReq.Uuid, err = runtime.String(val)
734 if err != nil {
735 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
736 }
737
738 msg, err := server.Lookup(ctx, &protoReq)
739 return msg, metadata, err
740
741 }
742
743 var (
744 filter_ABitOfEverythingService_Custom_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
745 )
746
747 func request_ABitOfEverythingService_Custom_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
748 var protoReq ABitOfEverything
749 var metadata runtime.ServerMetadata
750
751 var (
752 val string
753 ok bool
754 err error
755 _ = err
756 )
757
758 val, ok = pathParams["uuid"]
759 if !ok {
760 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
761 }
762
763 protoReq.Uuid, err = runtime.String(val)
764 if err != nil {
765 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
766 }
767
768 if err := req.ParseForm(); err != nil {
769 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
770 }
771 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Custom_0); err != nil {
772 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
773 }
774
775 msg, err := client.Custom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
776 return msg, metadata, err
777
778 }
779
780 func local_request_ABitOfEverythingService_Custom_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
781 var protoReq ABitOfEverything
782 var metadata runtime.ServerMetadata
783
784 var (
785 val string
786 ok bool
787 err error
788 _ = err
789 )
790
791 val, ok = pathParams["uuid"]
792 if !ok {
793 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
794 }
795
796 protoReq.Uuid, err = runtime.String(val)
797 if err != nil {
798 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
799 }
800
801 if err := req.ParseForm(); err != nil {
802 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
803 }
804 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Custom_0); err != nil {
805 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
806 }
807
808 msg, err := server.Custom(ctx, &protoReq)
809 return msg, metadata, err
810
811 }
812
813 var (
814 filter_ABitOfEverythingService_DoubleColon_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
815 )
816
817 func request_ABitOfEverythingService_DoubleColon_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
818 var protoReq ABitOfEverything
819 var metadata runtime.ServerMetadata
820
821 var (
822 val string
823 ok bool
824 err error
825 _ = err
826 )
827
828 val, ok = pathParams["uuid"]
829 if !ok {
830 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
831 }
832
833 protoReq.Uuid, err = runtime.String(val)
834 if err != nil {
835 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
836 }
837
838 if err := req.ParseForm(); err != nil {
839 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
840 }
841 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_DoubleColon_0); err != nil {
842 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
843 }
844
845 msg, err := client.DoubleColon(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
846 return msg, metadata, err
847
848 }
849
850 func local_request_ABitOfEverythingService_DoubleColon_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
851 var protoReq ABitOfEverything
852 var metadata runtime.ServerMetadata
853
854 var (
855 val string
856 ok bool
857 err error
858 _ = err
859 )
860
861 val, ok = pathParams["uuid"]
862 if !ok {
863 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
864 }
865
866 protoReq.Uuid, err = runtime.String(val)
867 if err != nil {
868 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
869 }
870
871 if err := req.ParseForm(); err != nil {
872 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
873 }
874 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_DoubleColon_0); err != nil {
875 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
876 }
877
878 msg, err := server.DoubleColon(ctx, &protoReq)
879 return msg, metadata, err
880
881 }
882
883 func request_ABitOfEverythingService_Update_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
884 var protoReq ABitOfEverything
885 var metadata runtime.ServerMetadata
886
887 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
888 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
889 }
890
891 var (
892 val string
893 ok bool
894 err error
895 _ = err
896 )
897
898 val, ok = pathParams["uuid"]
899 if !ok {
900 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
901 }
902
903 protoReq.Uuid, err = runtime.String(val)
904 if err != nil {
905 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
906 }
907
908 msg, err := client.Update(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
909 return msg, metadata, err
910
911 }
912
913 func local_request_ABitOfEverythingService_Update_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
914 var protoReq ABitOfEverything
915 var metadata runtime.ServerMetadata
916
917 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
918 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
919 }
920
921 var (
922 val string
923 ok bool
924 err error
925 _ = err
926 )
927
928 val, ok = pathParams["uuid"]
929 if !ok {
930 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
931 }
932
933 protoReq.Uuid, err = runtime.String(val)
934 if err != nil {
935 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
936 }
937
938 msg, err := server.Update(ctx, &protoReq)
939 return msg, metadata, err
940
941 }
942
943 var (
944 filter_ABitOfEverythingService_UpdateV2_0 = &utilities.DoubleArray{Encoding: map[string]int{"abe": 0, "uuid": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}}
945 )
946
947 func request_ABitOfEverythingService_UpdateV2_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
948 var protoReq UpdateV2Request
949 var metadata runtime.ServerMetadata
950
951 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Abe); err != nil && err != io.EOF {
952 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
953 }
954
955 var (
956 val string
957 ok bool
958 err error
959 _ = err
960 )
961
962 val, ok = pathParams["abe.uuid"]
963 if !ok {
964 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
965 }
966
967 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
968 if err != nil {
969 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
970 }
971
972 if err := req.ParseForm(); err != nil {
973 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
974 }
975 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_0); err != nil {
976 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
977 }
978
979 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
980 return msg, metadata, err
981
982 }
983
984 func local_request_ABitOfEverythingService_UpdateV2_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
985 var protoReq UpdateV2Request
986 var metadata runtime.ServerMetadata
987
988 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Abe); err != nil && err != io.EOF {
989 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
990 }
991
992 var (
993 val string
994 ok bool
995 err error
996 _ = err
997 )
998
999 val, ok = pathParams["abe.uuid"]
1000 if !ok {
1001 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
1002 }
1003
1004 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
1005 if err != nil {
1006 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
1007 }
1008
1009 if err := req.ParseForm(); err != nil {
1010 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1011 }
1012 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_0); err != nil {
1013 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1014 }
1015
1016 msg, err := server.UpdateV2(ctx, &protoReq)
1017 return msg, metadata, err
1018
1019 }
1020
1021 var (
1022 filter_ABitOfEverythingService_UpdateV2_1 = &utilities.DoubleArray{Encoding: map[string]int{"abe": 0, "uuid": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}}
1023 )
1024
1025 func request_ABitOfEverythingService_UpdateV2_1(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1026 var protoReq UpdateV2Request
1027 var metadata runtime.ServerMetadata
1028
1029 newReader, berr := utilities.IOReaderFactory(req.Body)
1030 if berr != nil {
1031 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1032 }
1033 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF {
1034 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1035 }
1036 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
1037 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Abe); err != nil {
1038 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1039 } else {
1040 protoReq.UpdateMask = fieldMask
1041 }
1042 }
1043
1044 var (
1045 val string
1046 ok bool
1047 err error
1048 _ = err
1049 )
1050
1051 val, ok = pathParams["abe.uuid"]
1052 if !ok {
1053 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
1054 }
1055
1056 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
1057 if err != nil {
1058 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
1059 }
1060
1061 if err := req.ParseForm(); err != nil {
1062 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1063 }
1064 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_1); err != nil {
1065 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1066 }
1067
1068 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1069 return msg, metadata, err
1070
1071 }
1072
1073 func local_request_ABitOfEverythingService_UpdateV2_1(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1074 var protoReq UpdateV2Request
1075 var metadata runtime.ServerMetadata
1076
1077 newReader, berr := utilities.IOReaderFactory(req.Body)
1078 if berr != nil {
1079 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1080 }
1081 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF {
1082 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1083 }
1084 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
1085 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Abe); err != nil {
1086 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1087 } else {
1088 protoReq.UpdateMask = fieldMask
1089 }
1090 }
1091
1092 var (
1093 val string
1094 ok bool
1095 err error
1096 _ = err
1097 )
1098
1099 val, ok = pathParams["abe.uuid"]
1100 if !ok {
1101 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
1102 }
1103
1104 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
1105 if err != nil {
1106 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
1107 }
1108
1109 if err := req.ParseForm(); err != nil {
1110 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1111 }
1112 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_1); err != nil {
1113 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1114 }
1115
1116 msg, err := server.UpdateV2(ctx, &protoReq)
1117 return msg, metadata, err
1118
1119 }
1120
1121 func request_ABitOfEverythingService_UpdateV2_2(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1122 var protoReq UpdateV2Request
1123 var metadata runtime.ServerMetadata
1124
1125 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
1126 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1127 }
1128
1129 var (
1130 val string
1131 ok bool
1132 err error
1133 _ = err
1134 )
1135
1136 val, ok = pathParams["abe.uuid"]
1137 if !ok {
1138 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
1139 }
1140
1141 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
1142 if err != nil {
1143 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
1144 }
1145
1146 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1147 return msg, metadata, err
1148
1149 }
1150
1151 func local_request_ABitOfEverythingService_UpdateV2_2(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1152 var protoReq UpdateV2Request
1153 var metadata runtime.ServerMetadata
1154
1155 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
1156 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1157 }
1158
1159 var (
1160 val string
1161 ok bool
1162 err error
1163 _ = err
1164 )
1165
1166 val, ok = pathParams["abe.uuid"]
1167 if !ok {
1168 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
1169 }
1170
1171 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
1172 if err != nil {
1173 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
1174 }
1175
1176 msg, err := server.UpdateV2(ctx, &protoReq)
1177 return msg, metadata, err
1178
1179 }
1180
1181 func request_ABitOfEverythingService_Delete_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1182 var protoReq sub2.IdMessage
1183 var metadata runtime.ServerMetadata
1184
1185 var (
1186 val string
1187 ok bool
1188 err error
1189 _ = err
1190 )
1191
1192 val, ok = pathParams["uuid"]
1193 if !ok {
1194 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1195 }
1196
1197 protoReq.Uuid, err = runtime.String(val)
1198 if err != nil {
1199 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1200 }
1201
1202 msg, err := client.Delete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1203 return msg, metadata, err
1204
1205 }
1206
1207 func local_request_ABitOfEverythingService_Delete_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1208 var protoReq sub2.IdMessage
1209 var metadata runtime.ServerMetadata
1210
1211 var (
1212 val string
1213 ok bool
1214 err error
1215 _ = err
1216 )
1217
1218 val, ok = pathParams["uuid"]
1219 if !ok {
1220 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1221 }
1222
1223 protoReq.Uuid, err = runtime.String(val)
1224 if err != nil {
1225 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1226 }
1227
1228 msg, err := server.Delete(ctx, &protoReq)
1229 return msg, metadata, err
1230
1231 }
1232
1233 var (
1234 filter_ABitOfEverythingService_GetQuery_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
1235 )
1236
1237 func request_ABitOfEverythingService_GetQuery_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1238 var protoReq ABitOfEverything
1239 var metadata runtime.ServerMetadata
1240
1241 var (
1242 val string
1243 ok bool
1244 err error
1245 _ = err
1246 )
1247
1248 val, ok = pathParams["uuid"]
1249 if !ok {
1250 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1251 }
1252
1253 protoReq.Uuid, err = runtime.String(val)
1254 if err != nil {
1255 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1256 }
1257
1258 if err := req.ParseForm(); err != nil {
1259 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1260 }
1261 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_GetQuery_0); err != nil {
1262 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1263 }
1264
1265 msg, err := client.GetQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1266 return msg, metadata, err
1267
1268 }
1269
1270 func local_request_ABitOfEverythingService_GetQuery_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1271 var protoReq ABitOfEverything
1272 var metadata runtime.ServerMetadata
1273
1274 var (
1275 val string
1276 ok bool
1277 err error
1278 _ = err
1279 )
1280
1281 val, ok = pathParams["uuid"]
1282 if !ok {
1283 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1284 }
1285
1286 protoReq.Uuid, err = runtime.String(val)
1287 if err != nil {
1288 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1289 }
1290
1291 if err := req.ParseForm(); err != nil {
1292 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1293 }
1294 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_GetQuery_0); err != nil {
1295 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1296 }
1297
1298 msg, err := server.GetQuery(ctx, &protoReq)
1299 return msg, metadata, err
1300
1301 }
1302
1303 func request_ABitOfEverythingService_GetRepeatedQuery_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1304 var protoReq ABitOfEverythingRepeated
1305 var metadata runtime.ServerMetadata
1306
1307 var (
1308 val string
1309 es []int32
1310 ok bool
1311 err error
1312 _ = err
1313 )
1314
1315 val, ok = pathParams["path_repeated_float_value"]
1316 if !ok {
1317 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_float_value")
1318 }
1319
1320 protoReq.PathRepeatedFloatValue, err = runtime.Float32Slice(val, ",")
1321 if err != nil {
1322 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_float_value", err)
1323 }
1324
1325 val, ok = pathParams["path_repeated_double_value"]
1326 if !ok {
1327 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_double_value")
1328 }
1329
1330 protoReq.PathRepeatedDoubleValue, err = runtime.Float64Slice(val, ",")
1331 if err != nil {
1332 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_double_value", err)
1333 }
1334
1335 val, ok = pathParams["path_repeated_int64_value"]
1336 if !ok {
1337 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int64_value")
1338 }
1339
1340 protoReq.PathRepeatedInt64Value, err = runtime.Int64Slice(val, ",")
1341 if err != nil {
1342 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int64_value", err)
1343 }
1344
1345 val, ok = pathParams["path_repeated_uint64_value"]
1346 if !ok {
1347 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint64_value")
1348 }
1349
1350 protoReq.PathRepeatedUint64Value, err = runtime.Uint64Slice(val, ",")
1351 if err != nil {
1352 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint64_value", err)
1353 }
1354
1355 val, ok = pathParams["path_repeated_int32_value"]
1356 if !ok {
1357 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int32_value")
1358 }
1359
1360 protoReq.PathRepeatedInt32Value, err = runtime.Int32Slice(val, ",")
1361 if err != nil {
1362 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int32_value", err)
1363 }
1364
1365 val, ok = pathParams["path_repeated_fixed64_value"]
1366 if !ok {
1367 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed64_value")
1368 }
1369
1370 protoReq.PathRepeatedFixed64Value, err = runtime.Uint64Slice(val, ",")
1371 if err != nil {
1372 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed64_value", err)
1373 }
1374
1375 val, ok = pathParams["path_repeated_fixed32_value"]
1376 if !ok {
1377 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed32_value")
1378 }
1379
1380 protoReq.PathRepeatedFixed32Value, err = runtime.Uint32Slice(val, ",")
1381 if err != nil {
1382 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed32_value", err)
1383 }
1384
1385 val, ok = pathParams["path_repeated_bool_value"]
1386 if !ok {
1387 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bool_value")
1388 }
1389
1390 protoReq.PathRepeatedBoolValue, err = runtime.BoolSlice(val, ",")
1391 if err != nil {
1392 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bool_value", err)
1393 }
1394
1395 val, ok = pathParams["path_repeated_string_value"]
1396 if !ok {
1397 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_string_value")
1398 }
1399
1400 protoReq.PathRepeatedStringValue, err = runtime.StringSlice(val, ",")
1401 if err != nil {
1402 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_string_value", err)
1403 }
1404
1405 val, ok = pathParams["path_repeated_bytes_value"]
1406 if !ok {
1407 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bytes_value")
1408 }
1409
1410 protoReq.PathRepeatedBytesValue, err = runtime.BytesSlice(val, ",")
1411 if err != nil {
1412 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bytes_value", err)
1413 }
1414
1415 val, ok = pathParams["path_repeated_uint32_value"]
1416 if !ok {
1417 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint32_value")
1418 }
1419
1420 protoReq.PathRepeatedUint32Value, err = runtime.Uint32Slice(val, ",")
1421 if err != nil {
1422 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint32_value", err)
1423 }
1424
1425 val, ok = pathParams["path_repeated_enum_value"]
1426 if !ok {
1427 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_enum_value")
1428 }
1429
1430 es, err = runtime.EnumSlice(val, ",", NumericEnum_value)
1431 if err != nil {
1432 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_enum_value", err)
1433 }
1434
1435 s := make([]NumericEnum, len(es))
1436 for i, v := range es {
1437 s[i] = NumericEnum(v)
1438 }
1439 protoReq.PathRepeatedEnumValue = s
1440
1441 val, ok = pathParams["path_repeated_sfixed32_value"]
1442 if !ok {
1443 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed32_value")
1444 }
1445
1446 protoReq.PathRepeatedSfixed32Value, err = runtime.Int32Slice(val, ",")
1447 if err != nil {
1448 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed32_value", err)
1449 }
1450
1451 val, ok = pathParams["path_repeated_sfixed64_value"]
1452 if !ok {
1453 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed64_value")
1454 }
1455
1456 protoReq.PathRepeatedSfixed64Value, err = runtime.Int64Slice(val, ",")
1457 if err != nil {
1458 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed64_value", err)
1459 }
1460
1461 val, ok = pathParams["path_repeated_sint32_value"]
1462 if !ok {
1463 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint32_value")
1464 }
1465
1466 protoReq.PathRepeatedSint32Value, err = runtime.Int32Slice(val, ",")
1467 if err != nil {
1468 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint32_value", err)
1469 }
1470
1471 val, ok = pathParams["path_repeated_sint64_value"]
1472 if !ok {
1473 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint64_value")
1474 }
1475
1476 protoReq.PathRepeatedSint64Value, err = runtime.Int64Slice(val, ",")
1477 if err != nil {
1478 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint64_value", err)
1479 }
1480
1481 msg, err := client.GetRepeatedQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1482 return msg, metadata, err
1483
1484 }
1485
1486 func local_request_ABitOfEverythingService_GetRepeatedQuery_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1487 var protoReq ABitOfEverythingRepeated
1488 var metadata runtime.ServerMetadata
1489
1490 var (
1491 val string
1492 es []int32
1493 ok bool
1494 err error
1495 _ = err
1496 )
1497
1498 val, ok = pathParams["path_repeated_float_value"]
1499 if !ok {
1500 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_float_value")
1501 }
1502
1503 protoReq.PathRepeatedFloatValue, err = runtime.Float32Slice(val, ",")
1504 if err != nil {
1505 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_float_value", err)
1506 }
1507
1508 val, ok = pathParams["path_repeated_double_value"]
1509 if !ok {
1510 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_double_value")
1511 }
1512
1513 protoReq.PathRepeatedDoubleValue, err = runtime.Float64Slice(val, ",")
1514 if err != nil {
1515 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_double_value", err)
1516 }
1517
1518 val, ok = pathParams["path_repeated_int64_value"]
1519 if !ok {
1520 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int64_value")
1521 }
1522
1523 protoReq.PathRepeatedInt64Value, err = runtime.Int64Slice(val, ",")
1524 if err != nil {
1525 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int64_value", err)
1526 }
1527
1528 val, ok = pathParams["path_repeated_uint64_value"]
1529 if !ok {
1530 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint64_value")
1531 }
1532
1533 protoReq.PathRepeatedUint64Value, err = runtime.Uint64Slice(val, ",")
1534 if err != nil {
1535 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint64_value", err)
1536 }
1537
1538 val, ok = pathParams["path_repeated_int32_value"]
1539 if !ok {
1540 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int32_value")
1541 }
1542
1543 protoReq.PathRepeatedInt32Value, err = runtime.Int32Slice(val, ",")
1544 if err != nil {
1545 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int32_value", err)
1546 }
1547
1548 val, ok = pathParams["path_repeated_fixed64_value"]
1549 if !ok {
1550 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed64_value")
1551 }
1552
1553 protoReq.PathRepeatedFixed64Value, err = runtime.Uint64Slice(val, ",")
1554 if err != nil {
1555 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed64_value", err)
1556 }
1557
1558 val, ok = pathParams["path_repeated_fixed32_value"]
1559 if !ok {
1560 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed32_value")
1561 }
1562
1563 protoReq.PathRepeatedFixed32Value, err = runtime.Uint32Slice(val, ",")
1564 if err != nil {
1565 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed32_value", err)
1566 }
1567
1568 val, ok = pathParams["path_repeated_bool_value"]
1569 if !ok {
1570 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bool_value")
1571 }
1572
1573 protoReq.PathRepeatedBoolValue, err = runtime.BoolSlice(val, ",")
1574 if err != nil {
1575 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bool_value", err)
1576 }
1577
1578 val, ok = pathParams["path_repeated_string_value"]
1579 if !ok {
1580 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_string_value")
1581 }
1582
1583 protoReq.PathRepeatedStringValue, err = runtime.StringSlice(val, ",")
1584 if err != nil {
1585 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_string_value", err)
1586 }
1587
1588 val, ok = pathParams["path_repeated_bytes_value"]
1589 if !ok {
1590 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bytes_value")
1591 }
1592
1593 protoReq.PathRepeatedBytesValue, err = runtime.BytesSlice(val, ",")
1594 if err != nil {
1595 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bytes_value", err)
1596 }
1597
1598 val, ok = pathParams["path_repeated_uint32_value"]
1599 if !ok {
1600 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint32_value")
1601 }
1602
1603 protoReq.PathRepeatedUint32Value, err = runtime.Uint32Slice(val, ",")
1604 if err != nil {
1605 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint32_value", err)
1606 }
1607
1608 val, ok = pathParams["path_repeated_enum_value"]
1609 if !ok {
1610 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_enum_value")
1611 }
1612
1613 es, err = runtime.EnumSlice(val, ",", NumericEnum_value)
1614 if err != nil {
1615 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_enum_value", err)
1616 }
1617
1618 s := make([]NumericEnum, len(es))
1619 for i, v := range es {
1620 s[i] = NumericEnum(v)
1621 }
1622 protoReq.PathRepeatedEnumValue = s
1623
1624 val, ok = pathParams["path_repeated_sfixed32_value"]
1625 if !ok {
1626 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed32_value")
1627 }
1628
1629 protoReq.PathRepeatedSfixed32Value, err = runtime.Int32Slice(val, ",")
1630 if err != nil {
1631 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed32_value", err)
1632 }
1633
1634 val, ok = pathParams["path_repeated_sfixed64_value"]
1635 if !ok {
1636 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed64_value")
1637 }
1638
1639 protoReq.PathRepeatedSfixed64Value, err = runtime.Int64Slice(val, ",")
1640 if err != nil {
1641 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed64_value", err)
1642 }
1643
1644 val, ok = pathParams["path_repeated_sint32_value"]
1645 if !ok {
1646 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint32_value")
1647 }
1648
1649 protoReq.PathRepeatedSint32Value, err = runtime.Int32Slice(val, ",")
1650 if err != nil {
1651 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint32_value", err)
1652 }
1653
1654 val, ok = pathParams["path_repeated_sint64_value"]
1655 if !ok {
1656 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint64_value")
1657 }
1658
1659 protoReq.PathRepeatedSint64Value, err = runtime.Int64Slice(val, ",")
1660 if err != nil {
1661 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint64_value", err)
1662 }
1663
1664 msg, err := server.GetRepeatedQuery(ctx, &protoReq)
1665 return msg, metadata, err
1666
1667 }
1668
1669 func request_ABitOfEverythingService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1670 var protoReq sub.StringMessage
1671 var metadata runtime.ServerMetadata
1672
1673 var (
1674 val string
1675 ok bool
1676 err error
1677 _ = err
1678 )
1679
1680 val, ok = pathParams["value"]
1681 if !ok {
1682 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
1683 }
1684
1685 protoReq.Value, err = runtime.StringP(val)
1686 if err != nil {
1687 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
1688 }
1689
1690 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1691 return msg, metadata, err
1692
1693 }
1694
1695 func local_request_ABitOfEverythingService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1696 var protoReq sub.StringMessage
1697 var metadata runtime.ServerMetadata
1698
1699 var (
1700 val string
1701 ok bool
1702 err error
1703 _ = err
1704 )
1705
1706 val, ok = pathParams["value"]
1707 if !ok {
1708 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
1709 }
1710
1711 protoReq.Value, err = runtime.StringP(val)
1712 if err != nil {
1713 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
1714 }
1715
1716 msg, err := server.Echo(ctx, &protoReq)
1717 return msg, metadata, err
1718
1719 }
1720
1721 func request_ABitOfEverythingService_Echo_1(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1722 var protoReq sub.StringMessage
1723 var metadata runtime.ServerMetadata
1724
1725 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Value); err != nil && err != io.EOF {
1726 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1727 }
1728
1729 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1730 return msg, metadata, err
1731
1732 }
1733
1734 func local_request_ABitOfEverythingService_Echo_1(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1735 var protoReq sub.StringMessage
1736 var metadata runtime.ServerMetadata
1737
1738 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Value); err != nil && err != io.EOF {
1739 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1740 }
1741
1742 msg, err := server.Echo(ctx, &protoReq)
1743 return msg, metadata, err
1744
1745 }
1746
1747 var (
1748 filter_ABitOfEverythingService_Echo_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
1749 )
1750
1751 func request_ABitOfEverythingService_Echo_2(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1752 var protoReq sub.StringMessage
1753 var metadata runtime.ServerMetadata
1754
1755 if err := req.ParseForm(); err != nil {
1756 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1757 }
1758 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Echo_2); err != nil {
1759 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1760 }
1761
1762 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1763 return msg, metadata, err
1764
1765 }
1766
1767 func local_request_ABitOfEverythingService_Echo_2(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1768 var protoReq sub.StringMessage
1769 var metadata runtime.ServerMetadata
1770
1771 if err := req.ParseForm(); err != nil {
1772 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1773 }
1774 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Echo_2); err != nil {
1775 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1776 }
1777
1778 msg, err := server.Echo(ctx, &protoReq)
1779 return msg, metadata, err
1780
1781 }
1782
1783 func request_ABitOfEverythingService_DeepPathEcho_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1784 var protoReq ABitOfEverything
1785 var metadata runtime.ServerMetadata
1786
1787 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
1788 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1789 }
1790
1791 var (
1792 val string
1793 ok bool
1794 err error
1795 _ = err
1796 )
1797
1798 val, ok = pathParams["single_nested.name"]
1799 if !ok {
1800 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
1801 }
1802
1803 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
1804 if err != nil {
1805 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
1806 }
1807
1808 msg, err := client.DeepPathEcho(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1809 return msg, metadata, err
1810
1811 }
1812
1813 func local_request_ABitOfEverythingService_DeepPathEcho_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1814 var protoReq ABitOfEverything
1815 var metadata runtime.ServerMetadata
1816
1817 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
1818 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1819 }
1820
1821 var (
1822 val string
1823 ok bool
1824 err error
1825 _ = err
1826 )
1827
1828 val, ok = pathParams["single_nested.name"]
1829 if !ok {
1830 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
1831 }
1832
1833 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
1834 if err != nil {
1835 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
1836 }
1837
1838 msg, err := server.DeepPathEcho(ctx, &protoReq)
1839 return msg, metadata, err
1840
1841 }
1842
1843 func request_ABitOfEverythingService_Timeout_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1844 var protoReq emptypb.Empty
1845 var metadata runtime.ServerMetadata
1846
1847 msg, err := client.Timeout(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1848 return msg, metadata, err
1849
1850 }
1851
1852 func local_request_ABitOfEverythingService_Timeout_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1853 var protoReq emptypb.Empty
1854 var metadata runtime.ServerMetadata
1855
1856 msg, err := server.Timeout(ctx, &protoReq)
1857 return msg, metadata, err
1858
1859 }
1860
1861 func request_ABitOfEverythingService_ErrorWithDetails_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1862 var protoReq emptypb.Empty
1863 var metadata runtime.ServerMetadata
1864
1865 msg, err := client.ErrorWithDetails(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1866 return msg, metadata, err
1867
1868 }
1869
1870 func local_request_ABitOfEverythingService_ErrorWithDetails_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1871 var protoReq emptypb.Empty
1872 var metadata runtime.ServerMetadata
1873
1874 msg, err := server.ErrorWithDetails(ctx, &protoReq)
1875 return msg, metadata, err
1876
1877 }
1878
1879 func request_ABitOfEverythingService_GetMessageWithBody_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1880 var protoReq MessageWithBody
1881 var metadata runtime.ServerMetadata
1882
1883 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Data); err != nil && err != io.EOF {
1884 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1885 }
1886
1887 var (
1888 val string
1889 ok bool
1890 err error
1891 _ = err
1892 )
1893
1894 val, ok = pathParams["id"]
1895 if !ok {
1896 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
1897 }
1898
1899 protoReq.Id, err = runtime.String(val)
1900 if err != nil {
1901 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
1902 }
1903
1904 msg, err := client.GetMessageWithBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1905 return msg, metadata, err
1906
1907 }
1908
1909 func local_request_ABitOfEverythingService_GetMessageWithBody_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1910 var protoReq MessageWithBody
1911 var metadata runtime.ServerMetadata
1912
1913 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Data); err != nil && err != io.EOF {
1914 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1915 }
1916
1917 var (
1918 val string
1919 ok bool
1920 err error
1921 _ = err
1922 )
1923
1924 val, ok = pathParams["id"]
1925 if !ok {
1926 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
1927 }
1928
1929 protoReq.Id, err = runtime.String(val)
1930 if err != nil {
1931 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
1932 }
1933
1934 msg, err := server.GetMessageWithBody(ctx, &protoReq)
1935 return msg, metadata, err
1936
1937 }
1938
1939 func request_ABitOfEverythingService_PostWithEmptyBody_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1940 var protoReq Body
1941 var metadata runtime.ServerMetadata
1942
1943 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
1944 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1945 }
1946
1947 var (
1948 val string
1949 ok bool
1950 err error
1951 _ = err
1952 )
1953
1954 val, ok = pathParams["name"]
1955 if !ok {
1956 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
1957 }
1958
1959 protoReq.Name, err = runtime.String(val)
1960 if err != nil {
1961 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
1962 }
1963
1964 msg, err := client.PostWithEmptyBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1965 return msg, metadata, err
1966
1967 }
1968
1969 func local_request_ABitOfEverythingService_PostWithEmptyBody_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
1970 var protoReq Body
1971 var metadata runtime.ServerMetadata
1972
1973 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
1974 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1975 }
1976
1977 var (
1978 val string
1979 ok bool
1980 err error
1981 _ = err
1982 )
1983
1984 val, ok = pathParams["name"]
1985 if !ok {
1986 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
1987 }
1988
1989 protoReq.Name, err = runtime.String(val)
1990 if err != nil {
1991 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
1992 }
1993
1994 msg, err := server.PostWithEmptyBody(ctx, &protoReq)
1995 return msg, metadata, err
1996
1997 }
1998
1999 var (
2000 filter_ABitOfEverythingService_CheckGetQueryParams_0 = &utilities.DoubleArray{Encoding: map[string]int{"single_nested": 0, "name": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
2001 )
2002
2003 func request_ABitOfEverythingService_CheckGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2004 var protoReq ABitOfEverything
2005 var metadata runtime.ServerMetadata
2006
2007 var (
2008 val string
2009 ok bool
2010 err error
2011 _ = err
2012 )
2013
2014 val, ok = pathParams["single_nested.name"]
2015 if !ok {
2016 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
2017 }
2018
2019 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
2020 if err != nil {
2021 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
2022 }
2023
2024 if err := req.ParseForm(); err != nil {
2025 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2026 }
2027 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckGetQueryParams_0); err != nil {
2028 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2029 }
2030
2031 msg, err := client.CheckGetQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2032 return msg, metadata, err
2033
2034 }
2035
2036 func local_request_ABitOfEverythingService_CheckGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2037 var protoReq ABitOfEverything
2038 var metadata runtime.ServerMetadata
2039
2040 var (
2041 val string
2042 ok bool
2043 err error
2044 _ = err
2045 )
2046
2047 val, ok = pathParams["single_nested.name"]
2048 if !ok {
2049 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
2050 }
2051
2052 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
2053 if err != nil {
2054 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
2055 }
2056
2057 if err := req.ParseForm(); err != nil {
2058 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2059 }
2060 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckGetQueryParams_0); err != nil {
2061 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2062 }
2063
2064 msg, err := server.CheckGetQueryParams(ctx, &protoReq)
2065 return msg, metadata, err
2066
2067 }
2068
2069 var (
2070 filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = &utilities.DoubleArray{Encoding: map[string]int{"single_nested": 0, "ok": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
2071 )
2072
2073 func request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2074 var protoReq ABitOfEverything
2075 var metadata runtime.ServerMetadata
2076
2077 var (
2078 val string
2079 e int32
2080 ok bool
2081 err error
2082 _ = err
2083 )
2084
2085 val, ok = pathParams["single_nested.ok"]
2086 if !ok {
2087 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.ok")
2088 }
2089
2090 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.ok", val)
2091 if err != nil {
2092 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.ok", err)
2093 }
2094
2095 e, err = runtime.Enum(val, ABitOfEverything_Nested_DeepEnum_value)
2096 if err != nil {
2097 return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "single_nested.ok", err)
2098 }
2099
2100 protoReq.SingleNested.Ok = ABitOfEverything_Nested_DeepEnum(e)
2101
2102 if err := req.ParseForm(); err != nil {
2103 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2104 }
2105 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0); err != nil {
2106 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2107 }
2108
2109 msg, err := client.CheckNestedEnumGetQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2110 return msg, metadata, err
2111
2112 }
2113
2114 func local_request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2115 var protoReq ABitOfEverything
2116 var metadata runtime.ServerMetadata
2117
2118 var (
2119 val string
2120 e int32
2121 ok bool
2122 err error
2123 _ = err
2124 )
2125
2126 val, ok = pathParams["single_nested.ok"]
2127 if !ok {
2128 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.ok")
2129 }
2130
2131 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.ok", val)
2132 if err != nil {
2133 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.ok", err)
2134 }
2135
2136 e, err = runtime.Enum(val, ABitOfEverything_Nested_DeepEnum_value)
2137 if err != nil {
2138 return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "single_nested.ok", err)
2139 }
2140
2141 protoReq.SingleNested.Ok = ABitOfEverything_Nested_DeepEnum(e)
2142
2143 if err := req.ParseForm(); err != nil {
2144 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2145 }
2146 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0); err != nil {
2147 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2148 }
2149
2150 msg, err := server.CheckNestedEnumGetQueryParams(ctx, &protoReq)
2151 return msg, metadata, err
2152
2153 }
2154
2155 var (
2156 filter_ABitOfEverythingService_CheckPostQueryParams_0 = &utilities.DoubleArray{Encoding: map[string]int{"single_nested": 0, "string_value": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
2157 )
2158
2159 func request_ABitOfEverythingService_CheckPostQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2160 var protoReq ABitOfEverything
2161 var metadata runtime.ServerMetadata
2162
2163 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.SingleNested); err != nil && err != io.EOF {
2164 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2165 }
2166
2167 var (
2168 val string
2169 ok bool
2170 err error
2171 _ = err
2172 )
2173
2174 val, ok = pathParams["string_value"]
2175 if !ok {
2176 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
2177 }
2178
2179 protoReq.StringValue, err = runtime.String(val)
2180 if err != nil {
2181 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
2182 }
2183
2184 if err := req.ParseForm(); err != nil {
2185 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2186 }
2187 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckPostQueryParams_0); err != nil {
2188 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2189 }
2190
2191 msg, err := client.CheckPostQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2192 return msg, metadata, err
2193
2194 }
2195
2196 func local_request_ABitOfEverythingService_CheckPostQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2197 var protoReq ABitOfEverything
2198 var metadata runtime.ServerMetadata
2199
2200 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.SingleNested); err != nil && err != io.EOF {
2201 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2202 }
2203
2204 var (
2205 val string
2206 ok bool
2207 err error
2208 _ = err
2209 )
2210
2211 val, ok = pathParams["string_value"]
2212 if !ok {
2213 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
2214 }
2215
2216 protoReq.StringValue, err = runtime.String(val)
2217 if err != nil {
2218 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
2219 }
2220
2221 if err := req.ParseForm(); err != nil {
2222 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2223 }
2224 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckPostQueryParams_0); err != nil {
2225 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2226 }
2227
2228 msg, err := server.CheckPostQueryParams(ctx, &protoReq)
2229 return msg, metadata, err
2230
2231 }
2232
2233 func request_ABitOfEverythingService_OverwriteRequestContentType_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2234 var protoReq Body
2235 var metadata runtime.ServerMetadata
2236
2237 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
2238 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2239 }
2240
2241 msg, err := client.OverwriteRequestContentType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2242 return msg, metadata, err
2243
2244 }
2245
2246 func local_request_ABitOfEverythingService_OverwriteRequestContentType_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2247 var protoReq Body
2248 var metadata runtime.ServerMetadata
2249
2250 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
2251 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2252 }
2253
2254 msg, err := server.OverwriteRequestContentType(ctx, &protoReq)
2255 return msg, metadata, err
2256
2257 }
2258
2259 func request_ABitOfEverythingService_OverwriteResponseContentType_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2260 var protoReq emptypb.Empty
2261 var metadata runtime.ServerMetadata
2262
2263 msg, err := client.OverwriteResponseContentType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2264 return msg, metadata, err
2265
2266 }
2267
2268 func local_request_ABitOfEverythingService_OverwriteResponseContentType_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2269 var protoReq emptypb.Empty
2270 var metadata runtime.ServerMetadata
2271
2272 msg, err := server.OverwriteResponseContentType(ctx, &protoReq)
2273 return msg, metadata, err
2274
2275 }
2276
2277 func request_ABitOfEverythingService_CheckExternalPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2278 var protoReq pathenum.MessageWithPathEnum
2279 var metadata runtime.ServerMetadata
2280
2281 var (
2282 val string
2283 e int32
2284 ok bool
2285 err error
2286 _ = err
2287 )
2288
2289 val, ok = pathParams["value"]
2290 if !ok {
2291 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2292 }
2293
2294 e, err = runtime.Enum(val, pathenum.PathEnum_value)
2295 if err != nil {
2296 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2297 }
2298
2299 protoReq.Value = pathenum.PathEnum(e)
2300
2301 msg, err := client.CheckExternalPathEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2302 return msg, metadata, err
2303
2304 }
2305
2306 func local_request_ABitOfEverythingService_CheckExternalPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2307 var protoReq pathenum.MessageWithPathEnum
2308 var metadata runtime.ServerMetadata
2309
2310 var (
2311 val string
2312 e int32
2313 ok bool
2314 err error
2315 _ = err
2316 )
2317
2318 val, ok = pathParams["value"]
2319 if !ok {
2320 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2321 }
2322
2323 e, err = runtime.Enum(val, pathenum.PathEnum_value)
2324 if err != nil {
2325 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2326 }
2327
2328 protoReq.Value = pathenum.PathEnum(e)
2329
2330 msg, err := server.CheckExternalPathEnum(ctx, &protoReq)
2331 return msg, metadata, err
2332
2333 }
2334
2335 func request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2336 var protoReq pathenum.MessageWithNestedPathEnum
2337 var metadata runtime.ServerMetadata
2338
2339 var (
2340 val string
2341 e int32
2342 ok bool
2343 err error
2344 _ = err
2345 )
2346
2347 val, ok = pathParams["value"]
2348 if !ok {
2349 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2350 }
2351
2352 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
2353 if err != nil {
2354 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2355 }
2356
2357 protoReq.Value = pathenum.MessagePathEnum_NestedPathEnum(e)
2358
2359 msg, err := client.CheckExternalNestedPathEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2360 return msg, metadata, err
2361
2362 }
2363
2364 func local_request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2365 var protoReq pathenum.MessageWithNestedPathEnum
2366 var metadata runtime.ServerMetadata
2367
2368 var (
2369 val string
2370 e int32
2371 ok bool
2372 err error
2373 _ = err
2374 )
2375
2376 val, ok = pathParams["value"]
2377 if !ok {
2378 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2379 }
2380
2381 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
2382 if err != nil {
2383 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2384 }
2385
2386 protoReq.Value = pathenum.MessagePathEnum_NestedPathEnum(e)
2387
2388 msg, err := server.CheckExternalNestedPathEnum(ctx, &protoReq)
2389 return msg, metadata, err
2390
2391 }
2392
2393 func request_ABitOfEverythingService_CheckStatus_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2394 var protoReq emptypb.Empty
2395 var metadata runtime.ServerMetadata
2396
2397 msg, err := client.CheckStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2398 return msg, metadata, err
2399
2400 }
2401
2402 func local_request_ABitOfEverythingService_CheckStatus_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2403 var protoReq emptypb.Empty
2404 var metadata runtime.ServerMetadata
2405
2406 msg, err := server.CheckStatus(ctx, &protoReq)
2407 return msg, metadata, err
2408
2409 }
2410
2411 var (
2412 filter_ABitOfEverythingService_Exists_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
2413 )
2414
2415 func request_ABitOfEverythingService_Exists_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2416 var protoReq ABitOfEverything
2417 var metadata runtime.ServerMetadata
2418
2419 var (
2420 val string
2421 ok bool
2422 err error
2423 _ = err
2424 )
2425
2426 val, ok = pathParams["uuid"]
2427 if !ok {
2428 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
2429 }
2430
2431 protoReq.Uuid, err = runtime.String(val)
2432 if err != nil {
2433 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
2434 }
2435
2436 if err := req.ParseForm(); err != nil {
2437 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2438 }
2439 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Exists_0); err != nil {
2440 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2441 }
2442
2443 msg, err := client.Exists(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2444 return msg, metadata, err
2445
2446 }
2447
2448 func local_request_ABitOfEverythingService_Exists_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2449 var protoReq ABitOfEverything
2450 var metadata runtime.ServerMetadata
2451
2452 var (
2453 val string
2454 ok bool
2455 err error
2456 _ = err
2457 )
2458
2459 val, ok = pathParams["uuid"]
2460 if !ok {
2461 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
2462 }
2463
2464 protoReq.Uuid, err = runtime.String(val)
2465 if err != nil {
2466 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
2467 }
2468
2469 if err := req.ParseForm(); err != nil {
2470 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2471 }
2472 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Exists_0); err != nil {
2473 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2474 }
2475
2476 msg, err := server.Exists(ctx, &protoReq)
2477 return msg, metadata, err
2478
2479 }
2480
2481 var (
2482 filter_ABitOfEverythingService_CustomOptionsRequest_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
2483 )
2484
2485 func request_ABitOfEverythingService_CustomOptionsRequest_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2486 var protoReq ABitOfEverything
2487 var metadata runtime.ServerMetadata
2488
2489 var (
2490 val string
2491 ok bool
2492 err error
2493 _ = err
2494 )
2495
2496 val, ok = pathParams["uuid"]
2497 if !ok {
2498 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
2499 }
2500
2501 protoReq.Uuid, err = runtime.String(val)
2502 if err != nil {
2503 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
2504 }
2505
2506 if err := req.ParseForm(); err != nil {
2507 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2508 }
2509 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CustomOptionsRequest_0); err != nil {
2510 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2511 }
2512
2513 msg, err := client.CustomOptionsRequest(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2514 return msg, metadata, err
2515
2516 }
2517
2518 func local_request_ABitOfEverythingService_CustomOptionsRequest_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2519 var protoReq ABitOfEverything
2520 var metadata runtime.ServerMetadata
2521
2522 var (
2523 val string
2524 ok bool
2525 err error
2526 _ = err
2527 )
2528
2529 val, ok = pathParams["uuid"]
2530 if !ok {
2531 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
2532 }
2533
2534 protoReq.Uuid, err = runtime.String(val)
2535 if err != nil {
2536 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
2537 }
2538
2539 if err := req.ParseForm(); err != nil {
2540 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2541 }
2542 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CustomOptionsRequest_0); err != nil {
2543 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2544 }
2545
2546 msg, err := server.CustomOptionsRequest(ctx, &protoReq)
2547 return msg, metadata, err
2548
2549 }
2550
2551 var (
2552 filter_ABitOfEverythingService_TraceRequest_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
2553 )
2554
2555 func request_ABitOfEverythingService_TraceRequest_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2556 var protoReq ABitOfEverything
2557 var metadata runtime.ServerMetadata
2558
2559 var (
2560 val string
2561 ok bool
2562 err error
2563 _ = err
2564 )
2565
2566 val, ok = pathParams["uuid"]
2567 if !ok {
2568 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
2569 }
2570
2571 protoReq.Uuid, err = runtime.String(val)
2572 if err != nil {
2573 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
2574 }
2575
2576 if err := req.ParseForm(); err != nil {
2577 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2578 }
2579 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_TraceRequest_0); err != nil {
2580 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2581 }
2582
2583 msg, err := client.TraceRequest(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2584 return msg, metadata, err
2585
2586 }
2587
2588 func local_request_ABitOfEverythingService_TraceRequest_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2589 var protoReq ABitOfEverything
2590 var metadata runtime.ServerMetadata
2591
2592 var (
2593 val string
2594 ok bool
2595 err error
2596 _ = err
2597 )
2598
2599 val, ok = pathParams["uuid"]
2600 if !ok {
2601 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
2602 }
2603
2604 protoReq.Uuid, err = runtime.String(val)
2605 if err != nil {
2606 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
2607 }
2608
2609 if err := req.ParseForm(); err != nil {
2610 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2611 }
2612 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_TraceRequest_0); err != nil {
2613 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2614 }
2615
2616 msg, err := server.TraceRequest(ctx, &protoReq)
2617 return msg, metadata, err
2618
2619 }
2620
2621 func request_ABitOfEverythingService_PostOneofEnum_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2622 var protoReq oneofenum.OneofEnumMessage
2623 var metadata runtime.ServerMetadata
2624
2625 if protoReq.One == nil {
2626 protoReq.One = &oneofenum.OneofEnumMessage_ExampleEnum{}
2627 } else if _, ok := protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum); !ok {
2628 return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *oneofenum.OneofEnumMessage_ExampleEnum, but: %t\n", protoReq.One)
2629 }
2630 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum).ExampleEnum); err != nil && err != io.EOF {
2631 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2632 }
2633
2634 msg, err := client.PostOneofEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2635 return msg, metadata, err
2636
2637 }
2638
2639 func local_request_ABitOfEverythingService_PostOneofEnum_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2640 var protoReq oneofenum.OneofEnumMessage
2641 var metadata runtime.ServerMetadata
2642
2643 if protoReq.One == nil {
2644 protoReq.One = &oneofenum.OneofEnumMessage_ExampleEnum{}
2645 } else if _, ok := protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum); !ok {
2646 return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *oneofenum.OneofEnumMessage_ExampleEnum, but: %t\n", protoReq.One)
2647 }
2648 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum).ExampleEnum); err != nil && err != io.EOF {
2649 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2650 }
2651
2652 msg, err := server.PostOneofEnum(ctx, &protoReq)
2653 return msg, metadata, err
2654
2655 }
2656
2657 func request_ABitOfEverythingService_PostRequiredMessageType_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2658 var protoReq RequiredMessageTypeRequest
2659 var metadata runtime.ServerMetadata
2660
2661 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
2662 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2663 }
2664
2665 msg, err := client.PostRequiredMessageType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2666 return msg, metadata, err
2667
2668 }
2669
2670 func local_request_ABitOfEverythingService_PostRequiredMessageType_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2671 var protoReq RequiredMessageTypeRequest
2672 var metadata runtime.ServerMetadata
2673
2674 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
2675 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2676 }
2677
2678 msg, err := server.PostRequiredMessageType(ctx, &protoReq)
2679 return msg, metadata, err
2680
2681 }
2682
2683 func request_CamelCaseServiceName_Empty_0(ctx context.Context, marshaler runtime.Marshaler, client CamelCaseServiceNameClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2684 var protoReq emptypb.Empty
2685 var metadata runtime.ServerMetadata
2686
2687 msg, err := client.Empty(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2688 return msg, metadata, err
2689
2690 }
2691
2692 func local_request_CamelCaseServiceName_Empty_0(ctx context.Context, marshaler runtime.Marshaler, server CamelCaseServiceNameServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2693 var protoReq emptypb.Empty
2694 var metadata runtime.ServerMetadata
2695
2696 msg, err := server.Empty(ctx, &protoReq)
2697 return msg, metadata, err
2698
2699 }
2700
2701 func request_SnakeEnumService_SnakeEnum_0(ctx context.Context, marshaler runtime.Marshaler, client SnakeEnumServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2702 var protoReq SnakeEnumRequest
2703 var metadata runtime.ServerMetadata
2704
2705 var (
2706 val string
2707 e int32
2708 ok bool
2709 err error
2710 _ = err
2711 )
2712
2713 val, ok = pathParams["who"]
2714 if !ok {
2715 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "who")
2716 }
2717
2718 e, err = runtime.Enum(val, SnakeCase_0Enum_value)
2719 if err != nil {
2720 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "who", err)
2721 }
2722
2723 protoReq.Who = SnakeCase_0Enum(e)
2724
2725 val, ok = pathParams["what"]
2726 if !ok {
2727 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "what")
2728 }
2729
2730 e, err = runtime.Enum(val, SnakeCaseEnum_value)
2731 if err != nil {
2732 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "what", err)
2733 }
2734
2735 protoReq.What = SnakeCaseEnum(e)
2736
2737 val, ok = pathParams["where"]
2738 if !ok {
2739 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "where")
2740 }
2741
2742 e, err = runtime.Enum(val, pathenum.SnakeCaseForImport_value)
2743 if err != nil {
2744 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "where", err)
2745 }
2746
2747 protoReq.Where = pathenum.SnakeCaseForImport(e)
2748
2749 msg, err := client.SnakeEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2750 return msg, metadata, err
2751
2752 }
2753
2754 func local_request_SnakeEnumService_SnakeEnum_0(ctx context.Context, marshaler runtime.Marshaler, server SnakeEnumServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
2755 var protoReq SnakeEnumRequest
2756 var metadata runtime.ServerMetadata
2757
2758 var (
2759 val string
2760 e int32
2761 ok bool
2762 err error
2763 _ = err
2764 )
2765
2766 val, ok = pathParams["who"]
2767 if !ok {
2768 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "who")
2769 }
2770
2771 e, err = runtime.Enum(val, SnakeCase_0Enum_value)
2772 if err != nil {
2773 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "who", err)
2774 }
2775
2776 protoReq.Who = SnakeCase_0Enum(e)
2777
2778 val, ok = pathParams["what"]
2779 if !ok {
2780 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "what")
2781 }
2782
2783 e, err = runtime.Enum(val, SnakeCaseEnum_value)
2784 if err != nil {
2785 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "what", err)
2786 }
2787
2788 protoReq.What = SnakeCaseEnum(e)
2789
2790 val, ok = pathParams["where"]
2791 if !ok {
2792 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "where")
2793 }
2794
2795 e, err = runtime.Enum(val, pathenum.SnakeCaseForImport_value)
2796 if err != nil {
2797 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "where", err)
2798 }
2799
2800 protoReq.Where = pathenum.SnakeCaseForImport(e)
2801
2802 msg, err := server.SnakeEnum(ctx, &protoReq)
2803 return msg, metadata, err
2804
2805 }
2806
2807
2808
2809
2810
2811 func RegisterABitOfEverythingServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ABitOfEverythingServiceServer) error {
2812
2813 mux.Handle("POST", pattern_ABitOfEverythingService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2814 ctx, cancel := context.WithCancel(req.Context())
2815 defer cancel()
2816 var stream runtime.ServerTransportStream
2817 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2818 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2819 var err error
2820 var annotatedContext context.Context
2821 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Create", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{float_value}/{double_value}/{int64_value}/separator/{uint64_value}/{int32_value}/{fixed64_value}/{fixed32_value}/{bool_value}/{string_value=strprefix/*}/{uint32_value}/{sfixed32_value}/{sfixed64_value}/{sint32_value}/{sint64_value}/{nonConventionalNameValue}/{enum_value}/{path_enum_value}/{nested_path_enum_value}/{enum_value_annotation}"))
2822 if err != nil {
2823 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2824 return
2825 }
2826 resp, md, err := local_request_ABitOfEverythingService_Create_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2827 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2828 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2829 if err != nil {
2830 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2831 return
2832 }
2833
2834 forward_ABitOfEverythingService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2835
2836 })
2837
2838 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2839 ctx, cancel := context.WithCancel(req.Context())
2840 defer cancel()
2841 var stream runtime.ServerTransportStream
2842 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2843 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2844 var err error
2845 var annotatedContext context.Context
2846 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBody", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything"))
2847 if err != nil {
2848 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2849 return
2850 }
2851 resp, md, err := local_request_ABitOfEverythingService_CreateBody_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2852 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2853 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2854 if err != nil {
2855 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2856 return
2857 }
2858
2859 forward_ABitOfEverythingService_CreateBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2860
2861 })
2862
2863 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2864 ctx, cancel := context.WithCancel(req.Context())
2865 defer cancel()
2866 var stream runtime.ServerTransportStream
2867 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2868 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2869 var err error
2870 var annotatedContext context.Context
2871 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBook", runtime.WithHTTPPathPattern("/v1/{parent=publishers/*}/books"))
2872 if err != nil {
2873 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2874 return
2875 }
2876 resp, md, err := local_request_ABitOfEverythingService_CreateBook_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2877 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2878 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2879 if err != nil {
2880 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2881 return
2882 }
2883
2884 forward_ABitOfEverythingService_CreateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2885
2886 })
2887
2888 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2889 ctx, cancel := context.WithCancel(req.Context())
2890 defer cancel()
2891 var stream runtime.ServerTransportStream
2892 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2893 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2894 var err error
2895 var annotatedContext context.Context
2896 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateBook", runtime.WithHTTPPathPattern("/v1/{book.name=publishers/*/books/*}"))
2897 if err != nil {
2898 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2899 return
2900 }
2901 resp, md, err := local_request_ABitOfEverythingService_UpdateBook_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2902 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2903 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2904 if err != nil {
2905 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2906 return
2907 }
2908
2909 forward_ABitOfEverythingService_UpdateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2910
2911 })
2912
2913 mux.Handle("GET", pattern_ABitOfEverythingService_Lookup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2914 ctx, cancel := context.WithCancel(req.Context())
2915 defer cancel()
2916 var stream runtime.ServerTransportStream
2917 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2918 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2919 var err error
2920 var annotatedContext context.Context
2921 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Lookup", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
2922 if err != nil {
2923 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2924 return
2925 }
2926 resp, md, err := local_request_ABitOfEverythingService_Lookup_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2927 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2928 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2929 if err != nil {
2930 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2931 return
2932 }
2933
2934 forward_ABitOfEverythingService_Lookup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2935
2936 })
2937
2938 mux.Handle("POST", pattern_ABitOfEverythingService_Custom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2939 ctx, cancel := context.WithCancel(req.Context())
2940 defer cancel()
2941 var stream runtime.ServerTransportStream
2942 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2943 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2944 var err error
2945 var annotatedContext context.Context
2946 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Custom", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom"))
2947 if err != nil {
2948 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2949 return
2950 }
2951 resp, md, err := local_request_ABitOfEverythingService_Custom_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2952 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2953 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2954 if err != nil {
2955 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2956 return
2957 }
2958
2959 forward_ABitOfEverythingService_Custom_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2960
2961 })
2962
2963 mux.Handle("POST", pattern_ABitOfEverythingService_DoubleColon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2964 ctx, cancel := context.WithCancel(req.Context())
2965 defer cancel()
2966 var stream runtime.ServerTransportStream
2967 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2968 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2969 var err error
2970 var annotatedContext context.Context
2971 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DoubleColon", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom:custom"))
2972 if err != nil {
2973 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2974 return
2975 }
2976 resp, md, err := local_request_ABitOfEverythingService_DoubleColon_0(annotatedContext, inboundMarshaler, server, req, pathParams)
2977 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2978 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2979 if err != nil {
2980 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2981 return
2982 }
2983
2984 forward_ABitOfEverythingService_DoubleColon_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2985
2986 })
2987
2988 mux.Handle("PUT", pattern_ABitOfEverythingService_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2989 ctx, cancel := context.WithCancel(req.Context())
2990 defer cancel()
2991 var stream runtime.ServerTransportStream
2992 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2993 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2994 var err error
2995 var annotatedContext context.Context
2996 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Update", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
2997 if err != nil {
2998 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2999 return
3000 }
3001 resp, md, err := local_request_ABitOfEverythingService_Update_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3002 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3003 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3004 if err != nil {
3005 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3006 return
3007 }
3008
3009 forward_ABitOfEverythingService_Update_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3010
3011 })
3012
3013 mux.Handle("PUT", pattern_ABitOfEverythingService_UpdateV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3014 ctx, cancel := context.WithCancel(req.Context())
3015 defer cancel()
3016 var stream runtime.ServerTransportStream
3017 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3018 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3019 var err error
3020 var annotatedContext context.Context
3021 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}"))
3022 if err != nil {
3023 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3024 return
3025 }
3026 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3027 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3028 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3029 if err != nil {
3030 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3031 return
3032 }
3033
3034 forward_ABitOfEverythingService_UpdateV2_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3035
3036 })
3037
3038 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3039 ctx, cancel := context.WithCancel(req.Context())
3040 defer cancel()
3041 var stream runtime.ServerTransportStream
3042 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3043 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3044 var err error
3045 var annotatedContext context.Context
3046 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}"))
3047 if err != nil {
3048 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3049 return
3050 }
3051 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_1(annotatedContext, inboundMarshaler, server, req, pathParams)
3052 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3053 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3054 if err != nil {
3055 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3056 return
3057 }
3058
3059 forward_ABitOfEverythingService_UpdateV2_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3060
3061 })
3062
3063 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3064 ctx, cancel := context.WithCancel(req.Context())
3065 defer cancel()
3066 var stream runtime.ServerTransportStream
3067 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3068 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3069 var err error
3070 var annotatedContext context.Context
3071 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2a/example/a_bit_of_everything/{abe.uuid}"))
3072 if err != nil {
3073 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3074 return
3075 }
3076 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_2(annotatedContext, inboundMarshaler, server, req, pathParams)
3077 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3078 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3079 if err != nil {
3080 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3081 return
3082 }
3083
3084 forward_ABitOfEverythingService_UpdateV2_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3085
3086 })
3087
3088 mux.Handle("DELETE", pattern_ABitOfEverythingService_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3089 ctx, cancel := context.WithCancel(req.Context())
3090 defer cancel()
3091 var stream runtime.ServerTransportStream
3092 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3093 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3094 var err error
3095 var annotatedContext context.Context
3096 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Delete", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
3097 if err != nil {
3098 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3099 return
3100 }
3101 resp, md, err := local_request_ABitOfEverythingService_Delete_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3102 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3103 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3104 if err != nil {
3105 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3106 return
3107 }
3108
3109 forward_ABitOfEverythingService_Delete_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3110
3111 })
3112
3113 mux.Handle("GET", pattern_ABitOfEverythingService_GetQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3114 ctx, cancel := context.WithCancel(req.Context())
3115 defer cancel()
3116 var stream runtime.ServerTransportStream
3117 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3118 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3119 var err error
3120 var annotatedContext context.Context
3121 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/query/{uuid}"))
3122 if err != nil {
3123 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3124 return
3125 }
3126 resp, md, err := local_request_ABitOfEverythingService_GetQuery_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3127 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3128 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3129 if err != nil {
3130 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3131 return
3132 }
3133
3134 forward_ABitOfEverythingService_GetQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3135
3136 })
3137
3138 mux.Handle("GET", pattern_ABitOfEverythingService_GetRepeatedQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3139 ctx, cancel := context.WithCancel(req.Context())
3140 defer cancel()
3141 var stream runtime.ServerTransportStream
3142 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3143 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3144 var err error
3145 var annotatedContext context.Context
3146 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetRepeatedQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything_repeated/{path_repeated_float_value}/{path_repeated_double_value}/{path_repeated_int64_value}/{path_repeated_uint64_value}/{path_repeated_int32_value}/{path_repeated_fixed64_value}/{path_repeated_fixed32_value}/{path_repeated_bool_value}/{path_repeated_string_value}/{path_repeated_bytes_value}/{path_repeated_uint32_value}/{path_repeated_enum_value}/{path_repeated_sfixed32_value}/{path_repeated_sfixed64_value}/{path_repeated_sint32_value}/{path_repeated_sint64_value}"))
3147 if err != nil {
3148 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3149 return
3150 }
3151 resp, md, err := local_request_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3152 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3153 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3154 if err != nil {
3155 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3156 return
3157 }
3158
3159 forward_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3160
3161 })
3162
3163 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3164 ctx, cancel := context.WithCancel(req.Context())
3165 defer cancel()
3166 var stream runtime.ServerTransportStream
3167 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3168 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3169 var err error
3170 var annotatedContext context.Context
3171 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/echo/{value}"))
3172 if err != nil {
3173 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3174 return
3175 }
3176 resp, md, err := local_request_ABitOfEverythingService_Echo_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3177 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3178 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3179 if err != nil {
3180 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3181 return
3182 }
3183
3184 forward_ABitOfEverythingService_Echo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3185
3186 })
3187
3188 mux.Handle("POST", pattern_ABitOfEverythingService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3189 ctx, cancel := context.WithCancel(req.Context())
3190 defer cancel()
3191 var stream runtime.ServerTransportStream
3192 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3193 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3194 var err error
3195 var annotatedContext context.Context
3196 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo"))
3197 if err != nil {
3198 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3199 return
3200 }
3201 resp, md, err := local_request_ABitOfEverythingService_Echo_1(annotatedContext, inboundMarshaler, server, req, pathParams)
3202 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3203 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3204 if err != nil {
3205 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3206 return
3207 }
3208
3209 forward_ABitOfEverythingService_Echo_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3210
3211 })
3212
3213 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3214 ctx, cancel := context.WithCancel(req.Context())
3215 defer cancel()
3216 var stream runtime.ServerTransportStream
3217 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3218 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3219 var err error
3220 var annotatedContext context.Context
3221 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo"))
3222 if err != nil {
3223 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3224 return
3225 }
3226 resp, md, err := local_request_ABitOfEverythingService_Echo_2(annotatedContext, inboundMarshaler, server, req, pathParams)
3227 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3228 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3229 if err != nil {
3230 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3231 return
3232 }
3233
3234 forward_ABitOfEverythingService_Echo_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3235
3236 })
3237
3238 mux.Handle("POST", pattern_ABitOfEverythingService_DeepPathEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3239 ctx, cancel := context.WithCancel(req.Context())
3240 defer cancel()
3241 var stream runtime.ServerTransportStream
3242 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3243 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3244 var err error
3245 var annotatedContext context.Context
3246 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DeepPathEcho", runtime.WithHTTPPathPattern("/v1/example/deep_path/{single_nested.name}"))
3247 if err != nil {
3248 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3249 return
3250 }
3251 resp, md, err := local_request_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3252 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3253 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3254 if err != nil {
3255 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3256 return
3257 }
3258
3259 forward_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3260
3261 })
3262
3263 mux.Handle("GET", pattern_ABitOfEverythingService_Timeout_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3264 ctx, cancel := context.WithCancel(req.Context())
3265 defer cancel()
3266 var stream runtime.ServerTransportStream
3267 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3268 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3269 var err error
3270 var annotatedContext context.Context
3271 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Timeout", runtime.WithHTTPPathPattern("/v2/example/timeout"))
3272 if err != nil {
3273 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3274 return
3275 }
3276 resp, md, err := local_request_ABitOfEverythingService_Timeout_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3277 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3278 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3279 if err != nil {
3280 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3281 return
3282 }
3283
3284 forward_ABitOfEverythingService_Timeout_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3285
3286 })
3287
3288 mux.Handle("GET", pattern_ABitOfEverythingService_ErrorWithDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3289 ctx, cancel := context.WithCancel(req.Context())
3290 defer cancel()
3291 var stream runtime.ServerTransportStream
3292 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3293 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3294 var err error
3295 var annotatedContext context.Context
3296 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/ErrorWithDetails", runtime.WithHTTPPathPattern("/v2/example/errorwithdetails"))
3297 if err != nil {
3298 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3299 return
3300 }
3301 resp, md, err := local_request_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3302 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3303 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3304 if err != nil {
3305 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3306 return
3307 }
3308
3309 forward_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3310
3311 })
3312
3313 mux.Handle("POST", pattern_ABitOfEverythingService_GetMessageWithBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3314 ctx, cancel := context.WithCancel(req.Context())
3315 defer cancel()
3316 var stream runtime.ServerTransportStream
3317 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3318 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3319 var err error
3320 var annotatedContext context.Context
3321 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetMessageWithBody", runtime.WithHTTPPathPattern("/v2/example/withbody/{id}"))
3322 if err != nil {
3323 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3324 return
3325 }
3326 resp, md, err := local_request_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3327 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3328 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3329 if err != nil {
3330 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3331 return
3332 }
3333
3334 forward_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3335
3336 })
3337
3338 mux.Handle("POST", pattern_ABitOfEverythingService_PostWithEmptyBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3339 ctx, cancel := context.WithCancel(req.Context())
3340 defer cancel()
3341 var stream runtime.ServerTransportStream
3342 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3343 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3344 var err error
3345 var annotatedContext context.Context
3346 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostWithEmptyBody", runtime.WithHTTPPathPattern("/v2/example/postwithemptybody/{name}"))
3347 if err != nil {
3348 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3349 return
3350 }
3351 resp, md, err := local_request_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3352 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3353 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3354 if err != nil {
3355 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3356 return
3357 }
3358
3359 forward_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3360
3361 })
3362
3363 mux.Handle("GET", pattern_ABitOfEverythingService_CheckGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3364 ctx, cancel := context.WithCancel(req.Context())
3365 defer cancel()
3366 var stream runtime.ServerTransportStream
3367 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3368 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3369 var err error
3370 var annotatedContext context.Context
3371 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/{single_nested.name}"))
3372 if err != nil {
3373 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3374 return
3375 }
3376 resp, md, err := local_request_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3377 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3378 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3379 if err != nil {
3380 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3381 return
3382 }
3383
3384 forward_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3385
3386 })
3387
3388 mux.Handle("GET", pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3389 ctx, cancel := context.WithCancel(req.Context())
3390 defer cancel()
3391 var stream runtime.ServerTransportStream
3392 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3393 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3394 var err error
3395 var annotatedContext context.Context
3396 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckNestedEnumGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/nested_enum/{single_nested.ok}"))
3397 if err != nil {
3398 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3399 return
3400 }
3401 resp, md, err := local_request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3402 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3403 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3404 if err != nil {
3405 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3406 return
3407 }
3408
3409 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3410
3411 })
3412
3413 mux.Handle("POST", pattern_ABitOfEverythingService_CheckPostQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3414 ctx, cancel := context.WithCancel(req.Context())
3415 defer cancel()
3416 var stream runtime.ServerTransportStream
3417 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3418 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3419 var err error
3420 var annotatedContext context.Context
3421 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckPostQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/post/{string_value}"))
3422 if err != nil {
3423 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3424 return
3425 }
3426 resp, md, err := local_request_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3427 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3428 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3429 if err != nil {
3430 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3431 return
3432 }
3433
3434 forward_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3435
3436 })
3437
3438 mux.Handle("POST", pattern_ABitOfEverythingService_OverwriteRequestContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3439 ctx, cancel := context.WithCancel(req.Context())
3440 defer cancel()
3441 var stream runtime.ServerTransportStream
3442 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3443 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3444 var err error
3445 var annotatedContext context.Context
3446 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteRequestContentType", runtime.WithHTTPPathPattern("/v2/example/overwriterequestcontenttype"))
3447 if err != nil {
3448 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3449 return
3450 }
3451 resp, md, err := local_request_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3452 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3453 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3454 if err != nil {
3455 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3456 return
3457 }
3458
3459 forward_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3460
3461 })
3462
3463 mux.Handle("GET", pattern_ABitOfEverythingService_OverwriteResponseContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3464 ctx, cancel := context.WithCancel(req.Context())
3465 defer cancel()
3466 var stream runtime.ServerTransportStream
3467 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3468 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3469 var err error
3470 var annotatedContext context.Context
3471 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteResponseContentType", runtime.WithHTTPPathPattern("/v2/example/overwriteresponsecontenttype"))
3472 if err != nil {
3473 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3474 return
3475 }
3476 resp, md, err := local_request_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3477 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3478 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3479 if err != nil {
3480 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3481 return
3482 }
3483
3484 forward_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3485
3486 })
3487
3488 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3489 ctx, cancel := context.WithCancel(req.Context())
3490 defer cancel()
3491 var stream runtime.ServerTransportStream
3492 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3493 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3494 var err error
3495 var annotatedContext context.Context
3496 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalPathEnum", runtime.WithHTTPPathPattern("/v2/{value}:check"))
3497 if err != nil {
3498 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3499 return
3500 }
3501 resp, md, err := local_request_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3502 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3503 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3504 if err != nil {
3505 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3506 return
3507 }
3508
3509 forward_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3510
3511 })
3512
3513 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3514 ctx, cancel := context.WithCancel(req.Context())
3515 defer cancel()
3516 var stream runtime.ServerTransportStream
3517 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3518 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3519 var err error
3520 var annotatedContext context.Context
3521 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalNestedPathEnum", runtime.WithHTTPPathPattern("/v3/{value}:check"))
3522 if err != nil {
3523 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3524 return
3525 }
3526 resp, md, err := local_request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3527 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3528 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3529 if err != nil {
3530 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3531 return
3532 }
3533
3534 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3535
3536 })
3537
3538 mux.Handle("GET", pattern_ABitOfEverythingService_CheckStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3539 ctx, cancel := context.WithCancel(req.Context())
3540 defer cancel()
3541 var stream runtime.ServerTransportStream
3542 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3543 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3544 var err error
3545 var annotatedContext context.Context
3546 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckStatus", runtime.WithHTTPPathPattern("/v1/example/checkStatus"))
3547 if err != nil {
3548 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3549 return
3550 }
3551 resp, md, err := local_request_ABitOfEverythingService_CheckStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3552 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3553 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3554 if err != nil {
3555 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3556 return
3557 }
3558
3559 forward_ABitOfEverythingService_CheckStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3560
3561 })
3562
3563 mux.Handle("HEAD", pattern_ABitOfEverythingService_Exists_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3564 ctx, cancel := context.WithCancel(req.Context())
3565 defer cancel()
3566 var stream runtime.ServerTransportStream
3567 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3568 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3569 var err error
3570 var annotatedContext context.Context
3571 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Exists", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
3572 if err != nil {
3573 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3574 return
3575 }
3576 resp, md, err := local_request_ABitOfEverythingService_Exists_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3577 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3578 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3579 if err != nil {
3580 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3581 return
3582 }
3583
3584 forward_ABitOfEverythingService_Exists_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3585
3586 })
3587
3588 mux.Handle("OPTIONS", pattern_ABitOfEverythingService_CustomOptionsRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3589 ctx, cancel := context.WithCancel(req.Context())
3590 defer cancel()
3591 var stream runtime.ServerTransportStream
3592 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3593 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3594 var err error
3595 var annotatedContext context.Context
3596 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CustomOptionsRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
3597 if err != nil {
3598 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3599 return
3600 }
3601 resp, md, err := local_request_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3602 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3603 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3604 if err != nil {
3605 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3606 return
3607 }
3608
3609 forward_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3610
3611 })
3612
3613 mux.Handle("TRACE", pattern_ABitOfEverythingService_TraceRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3614 ctx, cancel := context.WithCancel(req.Context())
3615 defer cancel()
3616 var stream runtime.ServerTransportStream
3617 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3618 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3619 var err error
3620 var annotatedContext context.Context
3621 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/TraceRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
3622 if err != nil {
3623 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3624 return
3625 }
3626 resp, md, err := local_request_ABitOfEverythingService_TraceRequest_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3627 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3628 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3629 if err != nil {
3630 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3631 return
3632 }
3633
3634 forward_ABitOfEverythingService_TraceRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3635
3636 })
3637
3638 mux.Handle("POST", pattern_ABitOfEverythingService_PostOneofEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3639 ctx, cancel := context.WithCancel(req.Context())
3640 defer cancel()
3641 var stream runtime.ServerTransportStream
3642 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3643 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3644 var err error
3645 var annotatedContext context.Context
3646 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostOneofEnum", runtime.WithHTTPPathPattern("/v1/example/oneofenum"))
3647 if err != nil {
3648 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3649 return
3650 }
3651 resp, md, err := local_request_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3652 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3653 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3654 if err != nil {
3655 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3656 return
3657 }
3658
3659 forward_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3660
3661 })
3662
3663 mux.Handle("POST", pattern_ABitOfEverythingService_PostRequiredMessageType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3664 ctx, cancel := context.WithCancel(req.Context())
3665 defer cancel()
3666 var stream runtime.ServerTransportStream
3667 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3668 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3669 var err error
3670 var annotatedContext context.Context
3671 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostRequiredMessageType", runtime.WithHTTPPathPattern("/v1/example/requiredmessagetype"))
3672 if err != nil {
3673 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3674 return
3675 }
3676 resp, md, err := local_request_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3677 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3678 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3679 if err != nil {
3680 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3681 return
3682 }
3683
3684 forward_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3685
3686 })
3687
3688 return nil
3689 }
3690
3691
3692
3693
3694
3695 func RegisterCamelCaseServiceNameHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CamelCaseServiceNameServer) error {
3696
3697 mux.Handle("GET", pattern_CamelCaseServiceName_Empty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3698 ctx, cancel := context.WithCancel(req.Context())
3699 defer cancel()
3700 var stream runtime.ServerTransportStream
3701 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3702 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3703 var err error
3704 var annotatedContext context.Context
3705 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.CamelCaseServiceName/Empty", runtime.WithHTTPPathPattern("/v2/example/empty"))
3706 if err != nil {
3707 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3708 return
3709 }
3710 resp, md, err := local_request_CamelCaseServiceName_Empty_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3711 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3712 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3713 if err != nil {
3714 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3715 return
3716 }
3717
3718 forward_CamelCaseServiceName_Empty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3719
3720 })
3721
3722 return nil
3723 }
3724
3725
3726
3727
3728
3729 func RegisterSnakeEnumServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SnakeEnumServiceServer) error {
3730
3731 mux.Handle("GET", pattern_SnakeEnumService_SnakeEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3732 ctx, cancel := context.WithCancel(req.Context())
3733 defer cancel()
3734 var stream runtime.ServerTransportStream
3735 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
3736 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3737 var err error
3738 var annotatedContext context.Context
3739 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.SnakeEnumService/SnakeEnum", runtime.WithHTTPPathPattern("/v1/example/snake/{who}/{what}/{where}"))
3740 if err != nil {
3741 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3742 return
3743 }
3744 resp, md, err := local_request_SnakeEnumService_SnakeEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams)
3745 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
3746 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3747 if err != nil {
3748 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3749 return
3750 }
3751
3752 forward_SnakeEnumService_SnakeEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3753
3754 })
3755
3756 return nil
3757 }
3758
3759
3760
3761 func RegisterABitOfEverythingServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
3762 conn, err := grpc.DialContext(ctx, endpoint, opts...)
3763 if err != nil {
3764 return err
3765 }
3766 defer func() {
3767 if err != nil {
3768 if cerr := conn.Close(); cerr != nil {
3769 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
3770 }
3771 return
3772 }
3773 go func() {
3774 <-ctx.Done()
3775 if cerr := conn.Close(); cerr != nil {
3776 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
3777 }
3778 }()
3779 }()
3780
3781 return RegisterABitOfEverythingServiceHandler(ctx, mux, conn)
3782 }
3783
3784
3785
3786 func RegisterABitOfEverythingServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
3787 return RegisterABitOfEverythingServiceHandlerClient(ctx, mux, NewABitOfEverythingServiceClient(conn))
3788 }
3789
3790
3791
3792
3793
3794
3795 func RegisterABitOfEverythingServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ABitOfEverythingServiceClient) error {
3796
3797 mux.Handle("POST", pattern_ABitOfEverythingService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3798 ctx, cancel := context.WithCancel(req.Context())
3799 defer cancel()
3800 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3801 var err error
3802 var annotatedContext context.Context
3803 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Create", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{float_value}/{double_value}/{int64_value}/separator/{uint64_value}/{int32_value}/{fixed64_value}/{fixed32_value}/{bool_value}/{string_value=strprefix/*}/{uint32_value}/{sfixed32_value}/{sfixed64_value}/{sint32_value}/{sint64_value}/{nonConventionalNameValue}/{enum_value}/{path_enum_value}/{nested_path_enum_value}/{enum_value_annotation}"))
3804 if err != nil {
3805 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3806 return
3807 }
3808 resp, md, err := request_ABitOfEverythingService_Create_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3809 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3810 if err != nil {
3811 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3812 return
3813 }
3814
3815 forward_ABitOfEverythingService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3816
3817 })
3818
3819 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3820 ctx, cancel := context.WithCancel(req.Context())
3821 defer cancel()
3822 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3823 var err error
3824 var annotatedContext context.Context
3825 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBody", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything"))
3826 if err != nil {
3827 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3828 return
3829 }
3830 resp, md, err := request_ABitOfEverythingService_CreateBody_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3831 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3832 if err != nil {
3833 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3834 return
3835 }
3836
3837 forward_ABitOfEverythingService_CreateBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3838
3839 })
3840
3841 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3842 ctx, cancel := context.WithCancel(req.Context())
3843 defer cancel()
3844 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3845 var err error
3846 var annotatedContext context.Context
3847 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBook", runtime.WithHTTPPathPattern("/v1/{parent=publishers/*}/books"))
3848 if err != nil {
3849 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3850 return
3851 }
3852 resp, md, err := request_ABitOfEverythingService_CreateBook_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3853 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3854 if err != nil {
3855 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3856 return
3857 }
3858
3859 forward_ABitOfEverythingService_CreateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3860
3861 })
3862
3863 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3864 ctx, cancel := context.WithCancel(req.Context())
3865 defer cancel()
3866 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3867 var err error
3868 var annotatedContext context.Context
3869 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateBook", runtime.WithHTTPPathPattern("/v1/{book.name=publishers/*/books/*}"))
3870 if err != nil {
3871 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3872 return
3873 }
3874 resp, md, err := request_ABitOfEverythingService_UpdateBook_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3875 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3876 if err != nil {
3877 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3878 return
3879 }
3880
3881 forward_ABitOfEverythingService_UpdateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3882
3883 })
3884
3885 mux.Handle("GET", pattern_ABitOfEverythingService_Lookup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3886 ctx, cancel := context.WithCancel(req.Context())
3887 defer cancel()
3888 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3889 var err error
3890 var annotatedContext context.Context
3891 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Lookup", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
3892 if err != nil {
3893 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3894 return
3895 }
3896 resp, md, err := request_ABitOfEverythingService_Lookup_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3897 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3898 if err != nil {
3899 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3900 return
3901 }
3902
3903 forward_ABitOfEverythingService_Lookup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3904
3905 })
3906
3907 mux.Handle("POST", pattern_ABitOfEverythingService_Custom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3908 ctx, cancel := context.WithCancel(req.Context())
3909 defer cancel()
3910 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3911 var err error
3912 var annotatedContext context.Context
3913 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Custom", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom"))
3914 if err != nil {
3915 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3916 return
3917 }
3918 resp, md, err := request_ABitOfEverythingService_Custom_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3919 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3920 if err != nil {
3921 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3922 return
3923 }
3924
3925 forward_ABitOfEverythingService_Custom_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3926
3927 })
3928
3929 mux.Handle("POST", pattern_ABitOfEverythingService_DoubleColon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3930 ctx, cancel := context.WithCancel(req.Context())
3931 defer cancel()
3932 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3933 var err error
3934 var annotatedContext context.Context
3935 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DoubleColon", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom:custom"))
3936 if err != nil {
3937 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3938 return
3939 }
3940 resp, md, err := request_ABitOfEverythingService_DoubleColon_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3941 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3942 if err != nil {
3943 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3944 return
3945 }
3946
3947 forward_ABitOfEverythingService_DoubleColon_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3948
3949 })
3950
3951 mux.Handle("PUT", pattern_ABitOfEverythingService_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3952 ctx, cancel := context.WithCancel(req.Context())
3953 defer cancel()
3954 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3955 var err error
3956 var annotatedContext context.Context
3957 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Update", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
3958 if err != nil {
3959 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3960 return
3961 }
3962 resp, md, err := request_ABitOfEverythingService_Update_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3963 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3964 if err != nil {
3965 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3966 return
3967 }
3968
3969 forward_ABitOfEverythingService_Update_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3970
3971 })
3972
3973 mux.Handle("PUT", pattern_ABitOfEverythingService_UpdateV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3974 ctx, cancel := context.WithCancel(req.Context())
3975 defer cancel()
3976 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3977 var err error
3978 var annotatedContext context.Context
3979 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}"))
3980 if err != nil {
3981 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3982 return
3983 }
3984 resp, md, err := request_ABitOfEverythingService_UpdateV2_0(annotatedContext, inboundMarshaler, client, req, pathParams)
3985 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
3986 if err != nil {
3987 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
3988 return
3989 }
3990
3991 forward_ABitOfEverythingService_UpdateV2_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3992
3993 })
3994
3995 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3996 ctx, cancel := context.WithCancel(req.Context())
3997 defer cancel()
3998 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3999 var err error
4000 var annotatedContext context.Context
4001 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}"))
4002 if err != nil {
4003 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4004 return
4005 }
4006 resp, md, err := request_ABitOfEverythingService_UpdateV2_1(annotatedContext, inboundMarshaler, client, req, pathParams)
4007 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4008 if err != nil {
4009 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4010 return
4011 }
4012
4013 forward_ABitOfEverythingService_UpdateV2_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4014
4015 })
4016
4017 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4018 ctx, cancel := context.WithCancel(req.Context())
4019 defer cancel()
4020 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4021 var err error
4022 var annotatedContext context.Context
4023 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2a/example/a_bit_of_everything/{abe.uuid}"))
4024 if err != nil {
4025 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4026 return
4027 }
4028 resp, md, err := request_ABitOfEverythingService_UpdateV2_2(annotatedContext, inboundMarshaler, client, req, pathParams)
4029 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4030 if err != nil {
4031 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4032 return
4033 }
4034
4035 forward_ABitOfEverythingService_UpdateV2_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4036
4037 })
4038
4039 mux.Handle("DELETE", pattern_ABitOfEverythingService_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4040 ctx, cancel := context.WithCancel(req.Context())
4041 defer cancel()
4042 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4043 var err error
4044 var annotatedContext context.Context
4045 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Delete", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
4046 if err != nil {
4047 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4048 return
4049 }
4050 resp, md, err := request_ABitOfEverythingService_Delete_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4051 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4052 if err != nil {
4053 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4054 return
4055 }
4056
4057 forward_ABitOfEverythingService_Delete_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4058
4059 })
4060
4061 mux.Handle("GET", pattern_ABitOfEverythingService_GetQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4062 ctx, cancel := context.WithCancel(req.Context())
4063 defer cancel()
4064 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4065 var err error
4066 var annotatedContext context.Context
4067 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/query/{uuid}"))
4068 if err != nil {
4069 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4070 return
4071 }
4072 resp, md, err := request_ABitOfEverythingService_GetQuery_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4073 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4074 if err != nil {
4075 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4076 return
4077 }
4078
4079 forward_ABitOfEverythingService_GetQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4080
4081 })
4082
4083 mux.Handle("GET", pattern_ABitOfEverythingService_GetRepeatedQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4084 ctx, cancel := context.WithCancel(req.Context())
4085 defer cancel()
4086 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4087 var err error
4088 var annotatedContext context.Context
4089 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetRepeatedQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything_repeated/{path_repeated_float_value}/{path_repeated_double_value}/{path_repeated_int64_value}/{path_repeated_uint64_value}/{path_repeated_int32_value}/{path_repeated_fixed64_value}/{path_repeated_fixed32_value}/{path_repeated_bool_value}/{path_repeated_string_value}/{path_repeated_bytes_value}/{path_repeated_uint32_value}/{path_repeated_enum_value}/{path_repeated_sfixed32_value}/{path_repeated_sfixed64_value}/{path_repeated_sint32_value}/{path_repeated_sint64_value}"))
4090 if err != nil {
4091 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4092 return
4093 }
4094 resp, md, err := request_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4095 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4096 if err != nil {
4097 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4098 return
4099 }
4100
4101 forward_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4102
4103 })
4104
4105 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4106 ctx, cancel := context.WithCancel(req.Context())
4107 defer cancel()
4108 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4109 var err error
4110 var annotatedContext context.Context
4111 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/echo/{value}"))
4112 if err != nil {
4113 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4114 return
4115 }
4116 resp, md, err := request_ABitOfEverythingService_Echo_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4117 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4118 if err != nil {
4119 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4120 return
4121 }
4122
4123 forward_ABitOfEverythingService_Echo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4124
4125 })
4126
4127 mux.Handle("POST", pattern_ABitOfEverythingService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4128 ctx, cancel := context.WithCancel(req.Context())
4129 defer cancel()
4130 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4131 var err error
4132 var annotatedContext context.Context
4133 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo"))
4134 if err != nil {
4135 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4136 return
4137 }
4138 resp, md, err := request_ABitOfEverythingService_Echo_1(annotatedContext, inboundMarshaler, client, req, pathParams)
4139 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4140 if err != nil {
4141 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4142 return
4143 }
4144
4145 forward_ABitOfEverythingService_Echo_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4146
4147 })
4148
4149 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4150 ctx, cancel := context.WithCancel(req.Context())
4151 defer cancel()
4152 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4153 var err error
4154 var annotatedContext context.Context
4155 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo"))
4156 if err != nil {
4157 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4158 return
4159 }
4160 resp, md, err := request_ABitOfEverythingService_Echo_2(annotatedContext, inboundMarshaler, client, req, pathParams)
4161 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4162 if err != nil {
4163 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4164 return
4165 }
4166
4167 forward_ABitOfEverythingService_Echo_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4168
4169 })
4170
4171 mux.Handle("POST", pattern_ABitOfEverythingService_DeepPathEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4172 ctx, cancel := context.WithCancel(req.Context())
4173 defer cancel()
4174 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4175 var err error
4176 var annotatedContext context.Context
4177 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DeepPathEcho", runtime.WithHTTPPathPattern("/v1/example/deep_path/{single_nested.name}"))
4178 if err != nil {
4179 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4180 return
4181 }
4182 resp, md, err := request_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4183 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4184 if err != nil {
4185 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4186 return
4187 }
4188
4189 forward_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4190
4191 })
4192
4193 mux.Handle("GET", pattern_ABitOfEverythingService_Timeout_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4194 ctx, cancel := context.WithCancel(req.Context())
4195 defer cancel()
4196 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4197 var err error
4198 var annotatedContext context.Context
4199 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Timeout", runtime.WithHTTPPathPattern("/v2/example/timeout"))
4200 if err != nil {
4201 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4202 return
4203 }
4204 resp, md, err := request_ABitOfEverythingService_Timeout_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4205 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4206 if err != nil {
4207 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4208 return
4209 }
4210
4211 forward_ABitOfEverythingService_Timeout_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4212
4213 })
4214
4215 mux.Handle("GET", pattern_ABitOfEverythingService_ErrorWithDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4216 ctx, cancel := context.WithCancel(req.Context())
4217 defer cancel()
4218 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4219 var err error
4220 var annotatedContext context.Context
4221 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/ErrorWithDetails", runtime.WithHTTPPathPattern("/v2/example/errorwithdetails"))
4222 if err != nil {
4223 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4224 return
4225 }
4226 resp, md, err := request_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4227 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4228 if err != nil {
4229 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4230 return
4231 }
4232
4233 forward_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4234
4235 })
4236
4237 mux.Handle("POST", pattern_ABitOfEverythingService_GetMessageWithBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4238 ctx, cancel := context.WithCancel(req.Context())
4239 defer cancel()
4240 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4241 var err error
4242 var annotatedContext context.Context
4243 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetMessageWithBody", runtime.WithHTTPPathPattern("/v2/example/withbody/{id}"))
4244 if err != nil {
4245 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4246 return
4247 }
4248 resp, md, err := request_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4249 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4250 if err != nil {
4251 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4252 return
4253 }
4254
4255 forward_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4256
4257 })
4258
4259 mux.Handle("POST", pattern_ABitOfEverythingService_PostWithEmptyBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4260 ctx, cancel := context.WithCancel(req.Context())
4261 defer cancel()
4262 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4263 var err error
4264 var annotatedContext context.Context
4265 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostWithEmptyBody", runtime.WithHTTPPathPattern("/v2/example/postwithemptybody/{name}"))
4266 if err != nil {
4267 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4268 return
4269 }
4270 resp, md, err := request_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4271 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4272 if err != nil {
4273 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4274 return
4275 }
4276
4277 forward_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4278
4279 })
4280
4281 mux.Handle("GET", pattern_ABitOfEverythingService_CheckGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4282 ctx, cancel := context.WithCancel(req.Context())
4283 defer cancel()
4284 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4285 var err error
4286 var annotatedContext context.Context
4287 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/{single_nested.name}"))
4288 if err != nil {
4289 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4290 return
4291 }
4292 resp, md, err := request_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4293 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4294 if err != nil {
4295 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4296 return
4297 }
4298
4299 forward_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4300
4301 })
4302
4303 mux.Handle("GET", pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4304 ctx, cancel := context.WithCancel(req.Context())
4305 defer cancel()
4306 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4307 var err error
4308 var annotatedContext context.Context
4309 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckNestedEnumGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/nested_enum/{single_nested.ok}"))
4310 if err != nil {
4311 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4312 return
4313 }
4314 resp, md, err := request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4315 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4316 if err != nil {
4317 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4318 return
4319 }
4320
4321 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4322
4323 })
4324
4325 mux.Handle("POST", pattern_ABitOfEverythingService_CheckPostQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4326 ctx, cancel := context.WithCancel(req.Context())
4327 defer cancel()
4328 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4329 var err error
4330 var annotatedContext context.Context
4331 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckPostQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/post/{string_value}"))
4332 if err != nil {
4333 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4334 return
4335 }
4336 resp, md, err := request_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4337 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4338 if err != nil {
4339 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4340 return
4341 }
4342
4343 forward_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4344
4345 })
4346
4347 mux.Handle("POST", pattern_ABitOfEverythingService_OverwriteRequestContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4348 ctx, cancel := context.WithCancel(req.Context())
4349 defer cancel()
4350 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4351 var err error
4352 var annotatedContext context.Context
4353 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteRequestContentType", runtime.WithHTTPPathPattern("/v2/example/overwriterequestcontenttype"))
4354 if err != nil {
4355 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4356 return
4357 }
4358 resp, md, err := request_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4359 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4360 if err != nil {
4361 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4362 return
4363 }
4364
4365 forward_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4366
4367 })
4368
4369 mux.Handle("GET", pattern_ABitOfEverythingService_OverwriteResponseContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4370 ctx, cancel := context.WithCancel(req.Context())
4371 defer cancel()
4372 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4373 var err error
4374 var annotatedContext context.Context
4375 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteResponseContentType", runtime.WithHTTPPathPattern("/v2/example/overwriteresponsecontenttype"))
4376 if err != nil {
4377 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4378 return
4379 }
4380 resp, md, err := request_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4381 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4382 if err != nil {
4383 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4384 return
4385 }
4386
4387 forward_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4388
4389 })
4390
4391 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4392 ctx, cancel := context.WithCancel(req.Context())
4393 defer cancel()
4394 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4395 var err error
4396 var annotatedContext context.Context
4397 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalPathEnum", runtime.WithHTTPPathPattern("/v2/{value}:check"))
4398 if err != nil {
4399 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4400 return
4401 }
4402 resp, md, err := request_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4403 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4404 if err != nil {
4405 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4406 return
4407 }
4408
4409 forward_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4410
4411 })
4412
4413 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4414 ctx, cancel := context.WithCancel(req.Context())
4415 defer cancel()
4416 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4417 var err error
4418 var annotatedContext context.Context
4419 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalNestedPathEnum", runtime.WithHTTPPathPattern("/v3/{value}:check"))
4420 if err != nil {
4421 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4422 return
4423 }
4424 resp, md, err := request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4425 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4426 if err != nil {
4427 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4428 return
4429 }
4430
4431 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4432
4433 })
4434
4435 mux.Handle("GET", pattern_ABitOfEverythingService_CheckStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4436 ctx, cancel := context.WithCancel(req.Context())
4437 defer cancel()
4438 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4439 var err error
4440 var annotatedContext context.Context
4441 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckStatus", runtime.WithHTTPPathPattern("/v1/example/checkStatus"))
4442 if err != nil {
4443 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4444 return
4445 }
4446 resp, md, err := request_ABitOfEverythingService_CheckStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4447 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4448 if err != nil {
4449 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4450 return
4451 }
4452
4453 forward_ABitOfEverythingService_CheckStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4454
4455 })
4456
4457 mux.Handle("HEAD", pattern_ABitOfEverythingService_Exists_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4458 ctx, cancel := context.WithCancel(req.Context())
4459 defer cancel()
4460 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4461 var err error
4462 var annotatedContext context.Context
4463 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Exists", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
4464 if err != nil {
4465 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4466 return
4467 }
4468 resp, md, err := request_ABitOfEverythingService_Exists_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4469 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4470 if err != nil {
4471 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4472 return
4473 }
4474
4475 forward_ABitOfEverythingService_Exists_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4476
4477 })
4478
4479 mux.Handle("OPTIONS", pattern_ABitOfEverythingService_CustomOptionsRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4480 ctx, cancel := context.WithCancel(req.Context())
4481 defer cancel()
4482 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4483 var err error
4484 var annotatedContext context.Context
4485 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CustomOptionsRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
4486 if err != nil {
4487 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4488 return
4489 }
4490 resp, md, err := request_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4491 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4492 if err != nil {
4493 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4494 return
4495 }
4496
4497 forward_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4498
4499 })
4500
4501 mux.Handle("TRACE", pattern_ABitOfEverythingService_TraceRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4502 ctx, cancel := context.WithCancel(req.Context())
4503 defer cancel()
4504 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4505 var err error
4506 var annotatedContext context.Context
4507 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/TraceRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}"))
4508 if err != nil {
4509 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4510 return
4511 }
4512 resp, md, err := request_ABitOfEverythingService_TraceRequest_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4513 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4514 if err != nil {
4515 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4516 return
4517 }
4518
4519 forward_ABitOfEverythingService_TraceRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4520
4521 })
4522
4523 mux.Handle("POST", pattern_ABitOfEverythingService_PostOneofEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4524 ctx, cancel := context.WithCancel(req.Context())
4525 defer cancel()
4526 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4527 var err error
4528 var annotatedContext context.Context
4529 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostOneofEnum", runtime.WithHTTPPathPattern("/v1/example/oneofenum"))
4530 if err != nil {
4531 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4532 return
4533 }
4534 resp, md, err := request_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4535 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4536 if err != nil {
4537 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4538 return
4539 }
4540
4541 forward_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4542
4543 })
4544
4545 mux.Handle("POST", pattern_ABitOfEverythingService_PostRequiredMessageType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4546 ctx, cancel := context.WithCancel(req.Context())
4547 defer cancel()
4548 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4549 var err error
4550 var annotatedContext context.Context
4551 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostRequiredMessageType", runtime.WithHTTPPathPattern("/v1/example/requiredmessagetype"))
4552 if err != nil {
4553 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4554 return
4555 }
4556 resp, md, err := request_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4557 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4558 if err != nil {
4559 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4560 return
4561 }
4562
4563 forward_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4564
4565 })
4566
4567 return nil
4568 }
4569
4570 var (
4571 pattern_ABitOfEverythingService_Create_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 1, 0, 4, 1, 5, 8, 1, 0, 4, 1, 5, 9, 1, 0, 4, 1, 5, 10, 1, 0, 4, 1, 5, 11, 2, 12, 1, 0, 4, 2, 5, 13, 1, 0, 4, 1, 5, 14, 1, 0, 4, 1, 5, 15, 1, 0, 4, 1, 5, 16, 1, 0, 4, 1, 5, 17, 1, 0, 4, 1, 5, 18, 1, 0, 4, 1, 5, 19, 1, 0, 4, 1, 5, 20, 1, 0, 4, 1, 5, 21, 1, 0, 4, 1, 5, 22, 1, 0, 4, 1, 5, 23}, []string{"v1", "example", "a_bit_of_everything", "float_value", "double_value", "int64_value", "separator", "uint64_value", "int32_value", "fixed64_value", "fixed32_value", "bool_value", "strprefix", "string_value", "uint32_value", "sfixed32_value", "sfixed64_value", "sint32_value", "sint64_value", "nonConventionalNameValue", "enum_value", "path_enum_value", "nested_path_enum_value", "enum_value_annotation"}, ""))
4572
4573 pattern_ABitOfEverythingService_CreateBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "a_bit_of_everything"}, ""))
4574
4575 pattern_ABitOfEverythingService_CreateBook_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "publishers", "parent", "books"}, ""))
4576
4577 pattern_ABitOfEverythingService_UpdateBook_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "publishers", "books", "book.name"}, ""))
4578
4579 pattern_ABitOfEverythingService_Lookup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, ""))
4580
4581 pattern_ABitOfEverythingService_Custom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "custom"))
4582
4583 pattern_ABitOfEverythingService_DoubleColon_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "custom:custom"))
4584
4585 pattern_ABitOfEverythingService_Update_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, ""))
4586
4587 pattern_ABitOfEverythingService_UpdateV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "a_bit_of_everything", "abe.uuid"}, ""))
4588
4589 pattern_ABitOfEverythingService_UpdateV2_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "a_bit_of_everything", "abe.uuid"}, ""))
4590
4591 pattern_ABitOfEverythingService_UpdateV2_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2a", "example", "a_bit_of_everything", "abe.uuid"}, ""))
4592
4593 pattern_ABitOfEverythingService_Delete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, ""))
4594
4595 pattern_ABitOfEverythingService_GetQuery_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "a_bit_of_everything", "query", "uuid"}, ""))
4596
4597 pattern_ABitOfEverythingService_GetRepeatedQuery_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 1, 0, 4, 1, 5, 7, 1, 0, 4, 1, 5, 8, 1, 0, 4, 1, 5, 9, 1, 0, 4, 1, 5, 10, 1, 0, 4, 1, 5, 11, 1, 0, 4, 1, 5, 12, 1, 0, 4, 1, 5, 13, 1, 0, 4, 1, 5, 14, 1, 0, 4, 1, 5, 15, 1, 0, 4, 1, 5, 16, 1, 0, 4, 1, 5, 17, 1, 0, 4, 1, 5, 18}, []string{"v1", "example", "a_bit_of_everything_repeated", "path_repeated_float_value", "path_repeated_double_value", "path_repeated_int64_value", "path_repeated_uint64_value", "path_repeated_int32_value", "path_repeated_fixed64_value", "path_repeated_fixed32_value", "path_repeated_bool_value", "path_repeated_string_value", "path_repeated_bytes_value", "path_repeated_uint32_value", "path_repeated_enum_value", "path_repeated_sfixed32_value", "path_repeated_sfixed64_value", "path_repeated_sint32_value", "path_repeated_sint64_value"}, ""))
4598
4599 pattern_ABitOfEverythingService_Echo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "a_bit_of_everything", "echo", "value"}, ""))
4600
4601 pattern_ABitOfEverythingService_Echo_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "echo"}, ""))
4602
4603 pattern_ABitOfEverythingService_Echo_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "echo"}, ""))
4604
4605 pattern_ABitOfEverythingService_DeepPathEcho_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "deep_path", "single_nested.name"}, ""))
4606
4607 pattern_ABitOfEverythingService_Timeout_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "timeout"}, ""))
4608
4609 pattern_ABitOfEverythingService_ErrorWithDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "errorwithdetails"}, ""))
4610
4611 pattern_ABitOfEverythingService_GetMessageWithBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "withbody", "id"}, ""))
4612
4613 pattern_ABitOfEverythingService_PostWithEmptyBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "postwithemptybody", "name"}, ""))
4614
4615 pattern_ABitOfEverythingService_CheckGetQueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "a_bit_of_everything", "params", "get", "single_nested.name"}, ""))
4616
4617 pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"v1", "example", "a_bit_of_everything", "params", "get", "nested_enum", "single_nested.ok"}, ""))
4618
4619 pattern_ABitOfEverythingService_CheckPostQueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "a_bit_of_everything", "params", "post", "string_value"}, ""))
4620
4621 pattern_ABitOfEverythingService_OverwriteRequestContentType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "overwriterequestcontenttype"}, ""))
4622
4623 pattern_ABitOfEverythingService_OverwriteResponseContentType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "overwriteresponsecontenttype"}, ""))
4624
4625 pattern_ABitOfEverythingService_CheckExternalPathEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"v2", "value"}, "check"))
4626
4627 pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"v3", "value"}, "check"))
4628
4629 pattern_ABitOfEverythingService_CheckStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "checkStatus"}, ""))
4630
4631 pattern_ABitOfEverythingService_Exists_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, ""))
4632
4633 pattern_ABitOfEverythingService_CustomOptionsRequest_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, ""))
4634
4635 pattern_ABitOfEverythingService_TraceRequest_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, ""))
4636
4637 pattern_ABitOfEverythingService_PostOneofEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "oneofenum"}, ""))
4638
4639 pattern_ABitOfEverythingService_PostRequiredMessageType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "requiredmessagetype"}, ""))
4640 )
4641
4642 var (
4643 forward_ABitOfEverythingService_Create_0 = runtime.ForwardResponseMessage
4644
4645 forward_ABitOfEverythingService_CreateBody_0 = runtime.ForwardResponseMessage
4646
4647 forward_ABitOfEverythingService_CreateBook_0 = runtime.ForwardResponseMessage
4648
4649 forward_ABitOfEverythingService_UpdateBook_0 = runtime.ForwardResponseMessage
4650
4651 forward_ABitOfEverythingService_Lookup_0 = runtime.ForwardResponseMessage
4652
4653 forward_ABitOfEverythingService_Custom_0 = runtime.ForwardResponseMessage
4654
4655 forward_ABitOfEverythingService_DoubleColon_0 = runtime.ForwardResponseMessage
4656
4657 forward_ABitOfEverythingService_Update_0 = runtime.ForwardResponseMessage
4658
4659 forward_ABitOfEverythingService_UpdateV2_0 = runtime.ForwardResponseMessage
4660
4661 forward_ABitOfEverythingService_UpdateV2_1 = runtime.ForwardResponseMessage
4662
4663 forward_ABitOfEverythingService_UpdateV2_2 = runtime.ForwardResponseMessage
4664
4665 forward_ABitOfEverythingService_Delete_0 = runtime.ForwardResponseMessage
4666
4667 forward_ABitOfEverythingService_GetQuery_0 = runtime.ForwardResponseMessage
4668
4669 forward_ABitOfEverythingService_GetRepeatedQuery_0 = runtime.ForwardResponseMessage
4670
4671 forward_ABitOfEverythingService_Echo_0 = runtime.ForwardResponseMessage
4672
4673 forward_ABitOfEverythingService_Echo_1 = runtime.ForwardResponseMessage
4674
4675 forward_ABitOfEverythingService_Echo_2 = runtime.ForwardResponseMessage
4676
4677 forward_ABitOfEverythingService_DeepPathEcho_0 = runtime.ForwardResponseMessage
4678
4679 forward_ABitOfEverythingService_Timeout_0 = runtime.ForwardResponseMessage
4680
4681 forward_ABitOfEverythingService_ErrorWithDetails_0 = runtime.ForwardResponseMessage
4682
4683 forward_ABitOfEverythingService_GetMessageWithBody_0 = runtime.ForwardResponseMessage
4684
4685 forward_ABitOfEverythingService_PostWithEmptyBody_0 = runtime.ForwardResponseMessage
4686
4687 forward_ABitOfEverythingService_CheckGetQueryParams_0 = runtime.ForwardResponseMessage
4688
4689 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = runtime.ForwardResponseMessage
4690
4691 forward_ABitOfEverythingService_CheckPostQueryParams_0 = runtime.ForwardResponseMessage
4692
4693 forward_ABitOfEverythingService_OverwriteRequestContentType_0 = runtime.ForwardResponseMessage
4694
4695 forward_ABitOfEverythingService_OverwriteResponseContentType_0 = runtime.ForwardResponseMessage
4696
4697 forward_ABitOfEverythingService_CheckExternalPathEnum_0 = runtime.ForwardResponseMessage
4698
4699 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0 = runtime.ForwardResponseMessage
4700
4701 forward_ABitOfEverythingService_CheckStatus_0 = runtime.ForwardResponseMessage
4702
4703 forward_ABitOfEverythingService_Exists_0 = runtime.ForwardResponseMessage
4704
4705 forward_ABitOfEverythingService_CustomOptionsRequest_0 = runtime.ForwardResponseMessage
4706
4707 forward_ABitOfEverythingService_TraceRequest_0 = runtime.ForwardResponseMessage
4708
4709 forward_ABitOfEverythingService_PostOneofEnum_0 = runtime.ForwardResponseMessage
4710
4711 forward_ABitOfEverythingService_PostRequiredMessageType_0 = runtime.ForwardResponseMessage
4712 )
4713
4714
4715
4716 func RegisterCamelCaseServiceNameHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
4717 conn, err := grpc.DialContext(ctx, endpoint, opts...)
4718 if err != nil {
4719 return err
4720 }
4721 defer func() {
4722 if err != nil {
4723 if cerr := conn.Close(); cerr != nil {
4724 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
4725 }
4726 return
4727 }
4728 go func() {
4729 <-ctx.Done()
4730 if cerr := conn.Close(); cerr != nil {
4731 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
4732 }
4733 }()
4734 }()
4735
4736 return RegisterCamelCaseServiceNameHandler(ctx, mux, conn)
4737 }
4738
4739
4740
4741 func RegisterCamelCaseServiceNameHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
4742 return RegisterCamelCaseServiceNameHandlerClient(ctx, mux, NewCamelCaseServiceNameClient(conn))
4743 }
4744
4745
4746
4747
4748
4749
4750 func RegisterCamelCaseServiceNameHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CamelCaseServiceNameClient) error {
4751
4752 mux.Handle("GET", pattern_CamelCaseServiceName_Empty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4753 ctx, cancel := context.WithCancel(req.Context())
4754 defer cancel()
4755 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4756 var err error
4757 var annotatedContext context.Context
4758 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.CamelCaseServiceName/Empty", runtime.WithHTTPPathPattern("/v2/example/empty"))
4759 if err != nil {
4760 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4761 return
4762 }
4763 resp, md, err := request_CamelCaseServiceName_Empty_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4764 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4765 if err != nil {
4766 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4767 return
4768 }
4769
4770 forward_CamelCaseServiceName_Empty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4771
4772 })
4773
4774 return nil
4775 }
4776
4777 var (
4778 pattern_CamelCaseServiceName_Empty_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "empty"}, ""))
4779 )
4780
4781 var (
4782 forward_CamelCaseServiceName_Empty_0 = runtime.ForwardResponseMessage
4783 )
4784
4785
4786
4787 func RegisterSnakeEnumServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
4788 conn, err := grpc.DialContext(ctx, endpoint, opts...)
4789 if err != nil {
4790 return err
4791 }
4792 defer func() {
4793 if err != nil {
4794 if cerr := conn.Close(); cerr != nil {
4795 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
4796 }
4797 return
4798 }
4799 go func() {
4800 <-ctx.Done()
4801 if cerr := conn.Close(); cerr != nil {
4802 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
4803 }
4804 }()
4805 }()
4806
4807 return RegisterSnakeEnumServiceHandler(ctx, mux, conn)
4808 }
4809
4810
4811
4812 func RegisterSnakeEnumServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
4813 return RegisterSnakeEnumServiceHandlerClient(ctx, mux, NewSnakeEnumServiceClient(conn))
4814 }
4815
4816
4817
4818
4819
4820
4821 func RegisterSnakeEnumServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SnakeEnumServiceClient) error {
4822
4823 mux.Handle("GET", pattern_SnakeEnumService_SnakeEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
4824 ctx, cancel := context.WithCancel(req.Context())
4825 defer cancel()
4826 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
4827 var err error
4828 var annotatedContext context.Context
4829 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.SnakeEnumService/SnakeEnum", runtime.WithHTTPPathPattern("/v1/example/snake/{who}/{what}/{where}"))
4830 if err != nil {
4831 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
4832 return
4833 }
4834 resp, md, err := request_SnakeEnumService_SnakeEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams)
4835 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
4836 if err != nil {
4837 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
4838 return
4839 }
4840
4841 forward_SnakeEnumService_SnakeEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
4842
4843 })
4844
4845 return nil
4846 }
4847
4848 var (
4849 pattern_SnakeEnumService_SnakeEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "snake", "who", "what", "where"}, ""))
4850 )
4851
4852 var (
4853 forward_SnakeEnumService_SnakeEnum_0 = runtime.ForwardResponseMessage
4854 )
4855
View as plain text