1
2
3
4
9 package examplepb
10
11 import (
12 "context"
13 "io"
14 "net/http"
15
16 "github.com/golang/protobuf/descriptor"
17 "github.com/golang/protobuf/proto"
18 "github.com/golang/protobuf/ptypes/empty"
19 "github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/pathenum"
20 "github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/sub"
21 "github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/sub2"
22 "github.com/grpc-ecosystem/grpc-gateway/runtime"
23 "github.com/grpc-ecosystem/grpc-gateway/utilities"
24 "google.golang.org/grpc"
25 "google.golang.org/grpc/codes"
26 "google.golang.org/grpc/grpclog"
27 "google.golang.org/grpc/metadata"
28 "google.golang.org/grpc/status"
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 _ = descriptor.ForMessage
38 var _ = metadata.Join
39
40 var (
41 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}}
42 )
43
44 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) {
45 var protoReq ABitOfEverything
46 var metadata runtime.ServerMetadata
47
48 var (
49 val string
50 e int32
51 ok bool
52 err error
53 _ = err
54 )
55
56 val, ok = pathParams["float_value"]
57 if !ok {
58 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "float_value")
59 }
60
61 protoReq.FloatValue, err = runtime.Float32(val)
62
63 if err != nil {
64 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "float_value", err)
65 }
66
67 val, ok = pathParams["double_value"]
68 if !ok {
69 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "double_value")
70 }
71
72 protoReq.DoubleValue, err = runtime.Float64(val)
73
74 if err != nil {
75 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "double_value", err)
76 }
77
78 val, ok = pathParams["int64_value"]
79 if !ok {
80 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64_value")
81 }
82
83 protoReq.Int64Value, err = runtime.Int64(val)
84
85 if err != nil {
86 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64_value", err)
87 }
88
89 val, ok = pathParams["uint64_value"]
90 if !ok {
91 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64_value")
92 }
93
94 protoReq.Uint64Value, err = runtime.Uint64(val)
95
96 if err != nil {
97 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64_value", err)
98 }
99
100 val, ok = pathParams["int32_value"]
101 if !ok {
102 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32_value")
103 }
104
105 protoReq.Int32Value, err = runtime.Int32(val)
106
107 if err != nil {
108 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32_value", err)
109 }
110
111 val, ok = pathParams["fixed64_value"]
112 if !ok {
113 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed64_value")
114 }
115
116 protoReq.Fixed64Value, err = runtime.Uint64(val)
117
118 if err != nil {
119 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed64_value", err)
120 }
121
122 val, ok = pathParams["fixed32_value"]
123 if !ok {
124 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed32_value")
125 }
126
127 protoReq.Fixed32Value, err = runtime.Uint32(val)
128
129 if err != nil {
130 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed32_value", err)
131 }
132
133 val, ok = pathParams["bool_value"]
134 if !ok {
135 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bool_value")
136 }
137
138 protoReq.BoolValue, err = runtime.Bool(val)
139
140 if err != nil {
141 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bool_value", err)
142 }
143
144 val, ok = pathParams["string_value"]
145 if !ok {
146 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
147 }
148
149 protoReq.StringValue, err = runtime.String(val)
150
151 if err != nil {
152 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
153 }
154
155 val, ok = pathParams["uint32_value"]
156 if !ok {
157 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32_value")
158 }
159
160 protoReq.Uint32Value, err = runtime.Uint32(val)
161
162 if err != nil {
163 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32_value", err)
164 }
165
166 val, ok = pathParams["sfixed32_value"]
167 if !ok {
168 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed32_value")
169 }
170
171 protoReq.Sfixed32Value, err = runtime.Int32(val)
172
173 if err != nil {
174 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed32_value", err)
175 }
176
177 val, ok = pathParams["sfixed64_value"]
178 if !ok {
179 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed64_value")
180 }
181
182 protoReq.Sfixed64Value, err = runtime.Int64(val)
183
184 if err != nil {
185 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed64_value", err)
186 }
187
188 val, ok = pathParams["sint32_value"]
189 if !ok {
190 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint32_value")
191 }
192
193 protoReq.Sint32Value, err = runtime.Int32(val)
194
195 if err != nil {
196 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint32_value", err)
197 }
198
199 val, ok = pathParams["sint64_value"]
200 if !ok {
201 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint64_value")
202 }
203
204 protoReq.Sint64Value, err = runtime.Int64(val)
205
206 if err != nil {
207 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint64_value", err)
208 }
209
210 val, ok = pathParams["nonConventionalNameValue"]
211 if !ok {
212 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nonConventionalNameValue")
213 }
214
215 protoReq.NonConventionalNameValue, err = runtime.String(val)
216
217 if err != nil {
218 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nonConventionalNameValue", err)
219 }
220
221 val, ok = pathParams["enum_value"]
222 if !ok {
223 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value")
224 }
225
226 e, err = runtime.Enum(val, NumericEnum_value)
227
228 if err != nil {
229 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value", err)
230 }
231
232 protoReq.EnumValue = NumericEnum(e)
233
234 val, ok = pathParams["path_enum_value"]
235 if !ok {
236 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_enum_value")
237 }
238
239 e, err = runtime.Enum(val, pathenum.PathEnum_value)
240
241 if err != nil {
242 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_enum_value", err)
243 }
244
245 protoReq.PathEnumValue = pathenum.PathEnum(e)
246
247 val, ok = pathParams["nested_path_enum_value"]
248 if !ok {
249 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nested_path_enum_value")
250 }
251
252 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
253
254 if err != nil {
255 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nested_path_enum_value", err)
256 }
257
258 protoReq.NestedPathEnumValue = pathenum.MessagePathEnum_NestedPathEnum(e)
259
260 val, ok = pathParams["enum_value_annotation"]
261 if !ok {
262 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value_annotation")
263 }
264
265 e, err = runtime.Enum(val, NumericEnum_value)
266
267 if err != nil {
268 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value_annotation", err)
269 }
270
271 protoReq.EnumValueAnnotation = NumericEnum(e)
272
273 if err := req.ParseForm(); err != nil {
274 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
275 }
276 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Create_0); err != nil {
277 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
278 }
279
280 msg, err := client.Create(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
281 return msg, metadata, err
282
283 }
284
285 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) {
286 var protoReq ABitOfEverything
287 var metadata runtime.ServerMetadata
288
289 var (
290 val string
291 e int32
292 ok bool
293 err error
294 _ = err
295 )
296
297 val, ok = pathParams["float_value"]
298 if !ok {
299 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "float_value")
300 }
301
302 protoReq.FloatValue, err = runtime.Float32(val)
303
304 if err != nil {
305 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "float_value", err)
306 }
307
308 val, ok = pathParams["double_value"]
309 if !ok {
310 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "double_value")
311 }
312
313 protoReq.DoubleValue, err = runtime.Float64(val)
314
315 if err != nil {
316 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "double_value", err)
317 }
318
319 val, ok = pathParams["int64_value"]
320 if !ok {
321 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64_value")
322 }
323
324 protoReq.Int64Value, err = runtime.Int64(val)
325
326 if err != nil {
327 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64_value", err)
328 }
329
330 val, ok = pathParams["uint64_value"]
331 if !ok {
332 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64_value")
333 }
334
335 protoReq.Uint64Value, err = runtime.Uint64(val)
336
337 if err != nil {
338 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64_value", err)
339 }
340
341 val, ok = pathParams["int32_value"]
342 if !ok {
343 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32_value")
344 }
345
346 protoReq.Int32Value, err = runtime.Int32(val)
347
348 if err != nil {
349 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32_value", err)
350 }
351
352 val, ok = pathParams["fixed64_value"]
353 if !ok {
354 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed64_value")
355 }
356
357 protoReq.Fixed64Value, err = runtime.Uint64(val)
358
359 if err != nil {
360 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed64_value", err)
361 }
362
363 val, ok = pathParams["fixed32_value"]
364 if !ok {
365 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed32_value")
366 }
367
368 protoReq.Fixed32Value, err = runtime.Uint32(val)
369
370 if err != nil {
371 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed32_value", err)
372 }
373
374 val, ok = pathParams["bool_value"]
375 if !ok {
376 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bool_value")
377 }
378
379 protoReq.BoolValue, err = runtime.Bool(val)
380
381 if err != nil {
382 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bool_value", err)
383 }
384
385 val, ok = pathParams["string_value"]
386 if !ok {
387 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
388 }
389
390 protoReq.StringValue, err = runtime.String(val)
391
392 if err != nil {
393 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
394 }
395
396 val, ok = pathParams["uint32_value"]
397 if !ok {
398 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32_value")
399 }
400
401 protoReq.Uint32Value, err = runtime.Uint32(val)
402
403 if err != nil {
404 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32_value", err)
405 }
406
407 val, ok = pathParams["sfixed32_value"]
408 if !ok {
409 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed32_value")
410 }
411
412 protoReq.Sfixed32Value, err = runtime.Int32(val)
413
414 if err != nil {
415 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed32_value", err)
416 }
417
418 val, ok = pathParams["sfixed64_value"]
419 if !ok {
420 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed64_value")
421 }
422
423 protoReq.Sfixed64Value, err = runtime.Int64(val)
424
425 if err != nil {
426 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed64_value", err)
427 }
428
429 val, ok = pathParams["sint32_value"]
430 if !ok {
431 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint32_value")
432 }
433
434 protoReq.Sint32Value, err = runtime.Int32(val)
435
436 if err != nil {
437 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint32_value", err)
438 }
439
440 val, ok = pathParams["sint64_value"]
441 if !ok {
442 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint64_value")
443 }
444
445 protoReq.Sint64Value, err = runtime.Int64(val)
446
447 if err != nil {
448 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint64_value", err)
449 }
450
451 val, ok = pathParams["nonConventionalNameValue"]
452 if !ok {
453 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nonConventionalNameValue")
454 }
455
456 protoReq.NonConventionalNameValue, err = runtime.String(val)
457
458 if err != nil {
459 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nonConventionalNameValue", err)
460 }
461
462 val, ok = pathParams["enum_value"]
463 if !ok {
464 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value")
465 }
466
467 e, err = runtime.Enum(val, NumericEnum_value)
468
469 if err != nil {
470 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value", err)
471 }
472
473 protoReq.EnumValue = NumericEnum(e)
474
475 val, ok = pathParams["path_enum_value"]
476 if !ok {
477 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_enum_value")
478 }
479
480 e, err = runtime.Enum(val, pathenum.PathEnum_value)
481
482 if err != nil {
483 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_enum_value", err)
484 }
485
486 protoReq.PathEnumValue = pathenum.PathEnum(e)
487
488 val, ok = pathParams["nested_path_enum_value"]
489 if !ok {
490 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nested_path_enum_value")
491 }
492
493 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
494
495 if err != nil {
496 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nested_path_enum_value", err)
497 }
498
499 protoReq.NestedPathEnumValue = pathenum.MessagePathEnum_NestedPathEnum(e)
500
501 val, ok = pathParams["enum_value_annotation"]
502 if !ok {
503 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value_annotation")
504 }
505
506 e, err = runtime.Enum(val, NumericEnum_value)
507
508 if err != nil {
509 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value_annotation", err)
510 }
511
512 protoReq.EnumValueAnnotation = NumericEnum(e)
513
514 if err := req.ParseForm(); err != nil {
515 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
516 }
517 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Create_0); err != nil {
518 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
519 }
520
521 msg, err := server.Create(ctx, &protoReq)
522 return msg, metadata, err
523
524 }
525
526 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) {
527 var protoReq ABitOfEverything
528 var metadata runtime.ServerMetadata
529
530 newReader, berr := utilities.IOReaderFactory(req.Body)
531 if berr != nil {
532 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
533 }
534 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
535 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
536 }
537
538 msg, err := client.CreateBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
539 return msg, metadata, err
540
541 }
542
543 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) {
544 var protoReq ABitOfEverything
545 var metadata runtime.ServerMetadata
546
547 newReader, berr := utilities.IOReaderFactory(req.Body)
548 if berr != nil {
549 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
550 }
551 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
552 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
553 }
554
555 msg, err := server.CreateBody(ctx, &protoReq)
556 return msg, metadata, err
557
558 }
559
560 var (
561 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}}
562 )
563
564 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) {
565 var protoReq CreateBookRequest
566 var metadata runtime.ServerMetadata
567
568 newReader, berr := utilities.IOReaderFactory(req.Body)
569 if berr != nil {
570 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
571 }
572 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Book); err != nil && err != io.EOF {
573 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
574 }
575
576 var (
577 val string
578 ok bool
579 err error
580 _ = err
581 )
582
583 val, ok = pathParams["parent"]
584 if !ok {
585 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent")
586 }
587
588 protoReq.Parent, err = runtime.String(val)
589
590 if err != nil {
591 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err)
592 }
593
594 if err := req.ParseForm(); err != nil {
595 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
596 }
597 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CreateBook_0); err != nil {
598 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
599 }
600
601 msg, err := client.CreateBook(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
602 return msg, metadata, err
603
604 }
605
606 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) {
607 var protoReq CreateBookRequest
608 var metadata runtime.ServerMetadata
609
610 newReader, berr := utilities.IOReaderFactory(req.Body)
611 if berr != nil {
612 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
613 }
614 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Book); err != nil && err != io.EOF {
615 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
616 }
617
618 var (
619 val string
620 ok bool
621 err error
622 _ = err
623 )
624
625 val, ok = pathParams["parent"]
626 if !ok {
627 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent")
628 }
629
630 protoReq.Parent, err = runtime.String(val)
631
632 if err != nil {
633 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err)
634 }
635
636 if err := req.ParseForm(); err != nil {
637 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
638 }
639 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CreateBook_0); err != nil {
640 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
641 }
642
643 msg, err := server.CreateBook(ctx, &protoReq)
644 return msg, metadata, err
645
646 }
647
648 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) {
649 var protoReq sub2.IdMessage
650 var metadata runtime.ServerMetadata
651
652 var (
653 val string
654 ok bool
655 err error
656 _ = err
657 )
658
659 val, ok = pathParams["uuid"]
660 if !ok {
661 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
662 }
663
664 protoReq.Uuid, err = runtime.String(val)
665
666 if err != nil {
667 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
668 }
669
670 msg, err := client.Lookup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
671 return msg, metadata, err
672
673 }
674
675 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) {
676 var protoReq sub2.IdMessage
677 var metadata runtime.ServerMetadata
678
679 var (
680 val string
681 ok bool
682 err error
683 _ = err
684 )
685
686 val, ok = pathParams["uuid"]
687 if !ok {
688 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
689 }
690
691 protoReq.Uuid, err = runtime.String(val)
692
693 if err != nil {
694 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
695 }
696
697 msg, err := server.Lookup(ctx, &protoReq)
698 return msg, metadata, err
699
700 }
701
702 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) {
703 var protoReq ABitOfEverything
704 var metadata runtime.ServerMetadata
705
706 newReader, berr := utilities.IOReaderFactory(req.Body)
707 if berr != nil {
708 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
709 }
710 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
711 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
712 }
713
714 var (
715 val string
716 ok bool
717 err error
718 _ = err
719 )
720
721 val, ok = pathParams["uuid"]
722 if !ok {
723 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
724 }
725
726 protoReq.Uuid, err = runtime.String(val)
727
728 if err != nil {
729 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
730 }
731
732 msg, err := client.Update(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
733 return msg, metadata, err
734
735 }
736
737 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) {
738 var protoReq ABitOfEverything
739 var metadata runtime.ServerMetadata
740
741 newReader, berr := utilities.IOReaderFactory(req.Body)
742 if berr != nil {
743 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
744 }
745 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
746 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
747 }
748
749 var (
750 val string
751 ok bool
752 err error
753 _ = err
754 )
755
756 val, ok = pathParams["uuid"]
757 if !ok {
758 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
759 }
760
761 protoReq.Uuid, err = runtime.String(val)
762
763 if err != nil {
764 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
765 }
766
767 msg, err := server.Update(ctx, &protoReq)
768 return msg, metadata, err
769
770 }
771
772 var (
773 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}}
774 )
775
776 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) {
777 var protoReq UpdateV2Request
778 var metadata runtime.ServerMetadata
779
780 newReader, berr := utilities.IOReaderFactory(req.Body)
781 if berr != nil {
782 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
783 }
784 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF {
785 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
786 }
787
788 var (
789 val string
790 ok bool
791 err error
792 _ = err
793 )
794
795 val, ok = pathParams["abe.uuid"]
796 if !ok {
797 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
798 }
799
800 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
801
802 if err != nil {
803 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
804 }
805
806 if err := req.ParseForm(); err != nil {
807 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
808 }
809 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_0); err != nil {
810 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
811 }
812
813 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
814 return msg, metadata, err
815
816 }
817
818 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) {
819 var protoReq UpdateV2Request
820 var metadata runtime.ServerMetadata
821
822 newReader, berr := utilities.IOReaderFactory(req.Body)
823 if berr != nil {
824 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
825 }
826 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF {
827 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
828 }
829
830 var (
831 val string
832 ok bool
833 err error
834 _ = err
835 )
836
837 val, ok = pathParams["abe.uuid"]
838 if !ok {
839 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
840 }
841
842 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
843
844 if err != nil {
845 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
846 }
847
848 if err := req.ParseForm(); err != nil {
849 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
850 }
851 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_0); err != nil {
852 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
853 }
854
855 msg, err := server.UpdateV2(ctx, &protoReq)
856 return msg, metadata, err
857
858 }
859
860 var (
861 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}}
862 )
863
864 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) {
865 var protoReq UpdateV2Request
866 var metadata runtime.ServerMetadata
867
868 newReader, berr := utilities.IOReaderFactory(req.Body)
869 if berr != nil {
870 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
871 }
872 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF {
873 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
874 }
875 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
876 _, md := descriptor.ForMessage(protoReq.Abe)
877 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), md); err != nil {
878 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
879 } else {
880 protoReq.UpdateMask = fieldMask
881 }
882 }
883
884 var (
885 val string
886 ok bool
887 err error
888 _ = err
889 )
890
891 val, ok = pathParams["abe.uuid"]
892 if !ok {
893 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
894 }
895
896 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
897
898 if err != nil {
899 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
900 }
901
902 if err := req.ParseForm(); err != nil {
903 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
904 }
905 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_1); err != nil {
906 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
907 }
908
909 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
910 return msg, metadata, err
911
912 }
913
914 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) {
915 var protoReq UpdateV2Request
916 var metadata runtime.ServerMetadata
917
918 newReader, berr := utilities.IOReaderFactory(req.Body)
919 if berr != nil {
920 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
921 }
922 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF {
923 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
924 }
925 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
926 _, md := descriptor.ForMessage(protoReq.Abe)
927 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), md); err != nil {
928 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
929 } else {
930 protoReq.UpdateMask = fieldMask
931 }
932 }
933
934 var (
935 val string
936 ok bool
937 err error
938 _ = err
939 )
940
941 val, ok = pathParams["abe.uuid"]
942 if !ok {
943 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
944 }
945
946 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
947
948 if err != nil {
949 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
950 }
951
952 if err := req.ParseForm(); err != nil {
953 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
954 }
955 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_1); err != nil {
956 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
957 }
958
959 msg, err := server.UpdateV2(ctx, &protoReq)
960 return msg, metadata, err
961
962 }
963
964 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) {
965 var protoReq UpdateV2Request
966 var metadata runtime.ServerMetadata
967
968 newReader, berr := utilities.IOReaderFactory(req.Body)
969 if berr != nil {
970 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
971 }
972 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
973 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
974 }
975
976 var (
977 val string
978 ok bool
979 err error
980 _ = err
981 )
982
983 val, ok = pathParams["abe.uuid"]
984 if !ok {
985 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
986 }
987
988 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
989
990 if err != nil {
991 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
992 }
993
994 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
995 return msg, metadata, err
996
997 }
998
999 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) {
1000 var protoReq UpdateV2Request
1001 var metadata runtime.ServerMetadata
1002
1003 newReader, berr := utilities.IOReaderFactory(req.Body)
1004 if berr != nil {
1005 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1006 }
1007 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
1008 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1009 }
1010
1011 var (
1012 val string
1013 ok bool
1014 err error
1015 _ = err
1016 )
1017
1018 val, ok = pathParams["abe.uuid"]
1019 if !ok {
1020 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid")
1021 }
1022
1023 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val)
1024
1025 if err != nil {
1026 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err)
1027 }
1028
1029 msg, err := server.UpdateV2(ctx, &protoReq)
1030 return msg, metadata, err
1031
1032 }
1033
1034 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) {
1035 var protoReq sub2.IdMessage
1036 var metadata runtime.ServerMetadata
1037
1038 var (
1039 val string
1040 ok bool
1041 err error
1042 _ = err
1043 )
1044
1045 val, ok = pathParams["uuid"]
1046 if !ok {
1047 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1048 }
1049
1050 protoReq.Uuid, err = runtime.String(val)
1051
1052 if err != nil {
1053 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1054 }
1055
1056 msg, err := client.Delete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1057 return msg, metadata, err
1058
1059 }
1060
1061 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) {
1062 var protoReq sub2.IdMessage
1063 var metadata runtime.ServerMetadata
1064
1065 var (
1066 val string
1067 ok bool
1068 err error
1069 _ = err
1070 )
1071
1072 val, ok = pathParams["uuid"]
1073 if !ok {
1074 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1075 }
1076
1077 protoReq.Uuid, err = runtime.String(val)
1078
1079 if err != nil {
1080 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1081 }
1082
1083 msg, err := server.Delete(ctx, &protoReq)
1084 return msg, metadata, err
1085
1086 }
1087
1088 var (
1089 filter_ABitOfEverythingService_GetQuery_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
1090 )
1091
1092 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) {
1093 var protoReq ABitOfEverything
1094 var metadata runtime.ServerMetadata
1095
1096 var (
1097 val string
1098 ok bool
1099 err error
1100 _ = err
1101 )
1102
1103 val, ok = pathParams["uuid"]
1104 if !ok {
1105 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1106 }
1107
1108 protoReq.Uuid, err = runtime.String(val)
1109
1110 if err != nil {
1111 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1112 }
1113
1114 if err := req.ParseForm(); err != nil {
1115 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1116 }
1117 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_GetQuery_0); err != nil {
1118 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1119 }
1120
1121 msg, err := client.GetQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1122 return msg, metadata, err
1123
1124 }
1125
1126 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) {
1127 var protoReq ABitOfEverything
1128 var metadata runtime.ServerMetadata
1129
1130 var (
1131 val string
1132 ok bool
1133 err error
1134 _ = err
1135 )
1136
1137 val, ok = pathParams["uuid"]
1138 if !ok {
1139 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid")
1140 }
1141
1142 protoReq.Uuid, err = runtime.String(val)
1143
1144 if err != nil {
1145 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err)
1146 }
1147
1148 if err := req.ParseForm(); err != nil {
1149 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1150 }
1151 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_GetQuery_0); err != nil {
1152 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1153 }
1154
1155 msg, err := server.GetQuery(ctx, &protoReq)
1156 return msg, metadata, err
1157
1158 }
1159
1160 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) {
1161 var protoReq ABitOfEverythingRepeated
1162 var metadata runtime.ServerMetadata
1163
1164 var (
1165 val string
1166 es []int32
1167 ok bool
1168 err error
1169 _ = err
1170 )
1171
1172 val, ok = pathParams["path_repeated_float_value"]
1173 if !ok {
1174 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_float_value")
1175 }
1176
1177 protoReq.PathRepeatedFloatValue, err = runtime.Float32Slice(val, ",")
1178
1179 if err != nil {
1180 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_float_value", err)
1181 }
1182
1183 val, ok = pathParams["path_repeated_double_value"]
1184 if !ok {
1185 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_double_value")
1186 }
1187
1188 protoReq.PathRepeatedDoubleValue, err = runtime.Float64Slice(val, ",")
1189
1190 if err != nil {
1191 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_double_value", err)
1192 }
1193
1194 val, ok = pathParams["path_repeated_int64_value"]
1195 if !ok {
1196 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int64_value")
1197 }
1198
1199 protoReq.PathRepeatedInt64Value, err = runtime.Int64Slice(val, ",")
1200
1201 if err != nil {
1202 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int64_value", err)
1203 }
1204
1205 val, ok = pathParams["path_repeated_uint64_value"]
1206 if !ok {
1207 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint64_value")
1208 }
1209
1210 protoReq.PathRepeatedUint64Value, err = runtime.Uint64Slice(val, ",")
1211
1212 if err != nil {
1213 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint64_value", err)
1214 }
1215
1216 val, ok = pathParams["path_repeated_int32_value"]
1217 if !ok {
1218 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int32_value")
1219 }
1220
1221 protoReq.PathRepeatedInt32Value, err = runtime.Int32Slice(val, ",")
1222
1223 if err != nil {
1224 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int32_value", err)
1225 }
1226
1227 val, ok = pathParams["path_repeated_fixed64_value"]
1228 if !ok {
1229 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed64_value")
1230 }
1231
1232 protoReq.PathRepeatedFixed64Value, err = runtime.Uint64Slice(val, ",")
1233
1234 if err != nil {
1235 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed64_value", err)
1236 }
1237
1238 val, ok = pathParams["path_repeated_fixed32_value"]
1239 if !ok {
1240 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed32_value")
1241 }
1242
1243 protoReq.PathRepeatedFixed32Value, err = runtime.Uint32Slice(val, ",")
1244
1245 if err != nil {
1246 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed32_value", err)
1247 }
1248
1249 val, ok = pathParams["path_repeated_bool_value"]
1250 if !ok {
1251 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bool_value")
1252 }
1253
1254 protoReq.PathRepeatedBoolValue, err = runtime.BoolSlice(val, ",")
1255
1256 if err != nil {
1257 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bool_value", err)
1258 }
1259
1260 val, ok = pathParams["path_repeated_string_value"]
1261 if !ok {
1262 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_string_value")
1263 }
1264
1265 protoReq.PathRepeatedStringValue, err = runtime.StringSlice(val, ",")
1266
1267 if err != nil {
1268 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_string_value", err)
1269 }
1270
1271 val, ok = pathParams["path_repeated_bytes_value"]
1272 if !ok {
1273 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bytes_value")
1274 }
1275
1276 protoReq.PathRepeatedBytesValue, err = runtime.BytesSlice(val, ",")
1277
1278 if err != nil {
1279 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bytes_value", err)
1280 }
1281
1282 val, ok = pathParams["path_repeated_uint32_value"]
1283 if !ok {
1284 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint32_value")
1285 }
1286
1287 protoReq.PathRepeatedUint32Value, err = runtime.Uint32Slice(val, ",")
1288
1289 if err != nil {
1290 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint32_value", err)
1291 }
1292
1293 val, ok = pathParams["path_repeated_enum_value"]
1294 if !ok {
1295 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_enum_value")
1296 }
1297
1298 es, err = runtime.EnumSlice(val, ",", NumericEnum_value)
1299
1300 if err != nil {
1301 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_enum_value", err)
1302 }
1303
1304 s := make([]NumericEnum, len(es))
1305 for i, v := range es {
1306 s[i] = NumericEnum(v)
1307 }
1308 protoReq.PathRepeatedEnumValue = s
1309
1310 val, ok = pathParams["path_repeated_sfixed32_value"]
1311 if !ok {
1312 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed32_value")
1313 }
1314
1315 protoReq.PathRepeatedSfixed32Value, err = runtime.Int32Slice(val, ",")
1316
1317 if err != nil {
1318 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed32_value", err)
1319 }
1320
1321 val, ok = pathParams["path_repeated_sfixed64_value"]
1322 if !ok {
1323 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed64_value")
1324 }
1325
1326 protoReq.PathRepeatedSfixed64Value, err = runtime.Int64Slice(val, ",")
1327
1328 if err != nil {
1329 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed64_value", err)
1330 }
1331
1332 val, ok = pathParams["path_repeated_sint32_value"]
1333 if !ok {
1334 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint32_value")
1335 }
1336
1337 protoReq.PathRepeatedSint32Value, err = runtime.Int32Slice(val, ",")
1338
1339 if err != nil {
1340 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint32_value", err)
1341 }
1342
1343 val, ok = pathParams["path_repeated_sint64_value"]
1344 if !ok {
1345 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint64_value")
1346 }
1347
1348 protoReq.PathRepeatedSint64Value, err = runtime.Int64Slice(val, ",")
1349
1350 if err != nil {
1351 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint64_value", err)
1352 }
1353
1354 msg, err := client.GetRepeatedQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1355 return msg, metadata, err
1356
1357 }
1358
1359 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) {
1360 var protoReq ABitOfEverythingRepeated
1361 var metadata runtime.ServerMetadata
1362
1363 var (
1364 val string
1365 es []int32
1366 ok bool
1367 err error
1368 _ = err
1369 )
1370
1371 val, ok = pathParams["path_repeated_float_value"]
1372 if !ok {
1373 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_float_value")
1374 }
1375
1376 protoReq.PathRepeatedFloatValue, err = runtime.Float32Slice(val, ",")
1377
1378 if err != nil {
1379 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_float_value", err)
1380 }
1381
1382 val, ok = pathParams["path_repeated_double_value"]
1383 if !ok {
1384 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_double_value")
1385 }
1386
1387 protoReq.PathRepeatedDoubleValue, err = runtime.Float64Slice(val, ",")
1388
1389 if err != nil {
1390 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_double_value", err)
1391 }
1392
1393 val, ok = pathParams["path_repeated_int64_value"]
1394 if !ok {
1395 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int64_value")
1396 }
1397
1398 protoReq.PathRepeatedInt64Value, err = runtime.Int64Slice(val, ",")
1399
1400 if err != nil {
1401 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int64_value", err)
1402 }
1403
1404 val, ok = pathParams["path_repeated_uint64_value"]
1405 if !ok {
1406 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint64_value")
1407 }
1408
1409 protoReq.PathRepeatedUint64Value, err = runtime.Uint64Slice(val, ",")
1410
1411 if err != nil {
1412 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint64_value", err)
1413 }
1414
1415 val, ok = pathParams["path_repeated_int32_value"]
1416 if !ok {
1417 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int32_value")
1418 }
1419
1420 protoReq.PathRepeatedInt32Value, err = runtime.Int32Slice(val, ",")
1421
1422 if err != nil {
1423 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int32_value", err)
1424 }
1425
1426 val, ok = pathParams["path_repeated_fixed64_value"]
1427 if !ok {
1428 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed64_value")
1429 }
1430
1431 protoReq.PathRepeatedFixed64Value, err = runtime.Uint64Slice(val, ",")
1432
1433 if err != nil {
1434 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed64_value", err)
1435 }
1436
1437 val, ok = pathParams["path_repeated_fixed32_value"]
1438 if !ok {
1439 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed32_value")
1440 }
1441
1442 protoReq.PathRepeatedFixed32Value, err = runtime.Uint32Slice(val, ",")
1443
1444 if err != nil {
1445 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed32_value", err)
1446 }
1447
1448 val, ok = pathParams["path_repeated_bool_value"]
1449 if !ok {
1450 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bool_value")
1451 }
1452
1453 protoReq.PathRepeatedBoolValue, err = runtime.BoolSlice(val, ",")
1454
1455 if err != nil {
1456 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bool_value", err)
1457 }
1458
1459 val, ok = pathParams["path_repeated_string_value"]
1460 if !ok {
1461 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_string_value")
1462 }
1463
1464 protoReq.PathRepeatedStringValue, err = runtime.StringSlice(val, ",")
1465
1466 if err != nil {
1467 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_string_value", err)
1468 }
1469
1470 val, ok = pathParams["path_repeated_bytes_value"]
1471 if !ok {
1472 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bytes_value")
1473 }
1474
1475 protoReq.PathRepeatedBytesValue, err = runtime.BytesSlice(val, ",")
1476
1477 if err != nil {
1478 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bytes_value", err)
1479 }
1480
1481 val, ok = pathParams["path_repeated_uint32_value"]
1482 if !ok {
1483 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint32_value")
1484 }
1485
1486 protoReq.PathRepeatedUint32Value, err = runtime.Uint32Slice(val, ",")
1487
1488 if err != nil {
1489 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint32_value", err)
1490 }
1491
1492 val, ok = pathParams["path_repeated_enum_value"]
1493 if !ok {
1494 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_enum_value")
1495 }
1496
1497 es, err = runtime.EnumSlice(val, ",", NumericEnum_value)
1498
1499 if err != nil {
1500 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_enum_value", err)
1501 }
1502
1503 s := make([]NumericEnum, len(es))
1504 for i, v := range es {
1505 s[i] = NumericEnum(v)
1506 }
1507 protoReq.PathRepeatedEnumValue = s
1508
1509 val, ok = pathParams["path_repeated_sfixed32_value"]
1510 if !ok {
1511 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed32_value")
1512 }
1513
1514 protoReq.PathRepeatedSfixed32Value, err = runtime.Int32Slice(val, ",")
1515
1516 if err != nil {
1517 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed32_value", err)
1518 }
1519
1520 val, ok = pathParams["path_repeated_sfixed64_value"]
1521 if !ok {
1522 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed64_value")
1523 }
1524
1525 protoReq.PathRepeatedSfixed64Value, err = runtime.Int64Slice(val, ",")
1526
1527 if err != nil {
1528 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed64_value", err)
1529 }
1530
1531 val, ok = pathParams["path_repeated_sint32_value"]
1532 if !ok {
1533 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint32_value")
1534 }
1535
1536 protoReq.PathRepeatedSint32Value, err = runtime.Int32Slice(val, ",")
1537
1538 if err != nil {
1539 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint32_value", err)
1540 }
1541
1542 val, ok = pathParams["path_repeated_sint64_value"]
1543 if !ok {
1544 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint64_value")
1545 }
1546
1547 protoReq.PathRepeatedSint64Value, err = runtime.Int64Slice(val, ",")
1548
1549 if err != nil {
1550 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint64_value", err)
1551 }
1552
1553 msg, err := server.GetRepeatedQuery(ctx, &protoReq)
1554 return msg, metadata, err
1555
1556 }
1557
1558 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) {
1559 var protoReq sub.StringMessage
1560 var metadata runtime.ServerMetadata
1561
1562 var (
1563 val string
1564 ok bool
1565 err error
1566 _ = err
1567 )
1568
1569 val, ok = pathParams["value"]
1570 if !ok {
1571 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
1572 }
1573
1574 protoReq.Value, err = runtime.StringP(val)
1575
1576 if err != nil {
1577 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
1578 }
1579
1580 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1581 return msg, metadata, err
1582
1583 }
1584
1585 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) {
1586 var protoReq sub.StringMessage
1587 var metadata runtime.ServerMetadata
1588
1589 var (
1590 val string
1591 ok bool
1592 err error
1593 _ = err
1594 )
1595
1596 val, ok = pathParams["value"]
1597 if !ok {
1598 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
1599 }
1600
1601 protoReq.Value, err = runtime.StringP(val)
1602
1603 if err != nil {
1604 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
1605 }
1606
1607 msg, err := server.Echo(ctx, &protoReq)
1608 return msg, metadata, err
1609
1610 }
1611
1612 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) {
1613 var protoReq sub.StringMessage
1614 var metadata runtime.ServerMetadata
1615
1616 newReader, berr := utilities.IOReaderFactory(req.Body)
1617 if berr != nil {
1618 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1619 }
1620 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Value); err != nil && err != io.EOF {
1621 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1622 }
1623
1624 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1625 return msg, metadata, err
1626
1627 }
1628
1629 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) {
1630 var protoReq sub.StringMessage
1631 var metadata runtime.ServerMetadata
1632
1633 newReader, berr := utilities.IOReaderFactory(req.Body)
1634 if berr != nil {
1635 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1636 }
1637 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Value); err != nil && err != io.EOF {
1638 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1639 }
1640
1641 msg, err := server.Echo(ctx, &protoReq)
1642 return msg, metadata, err
1643
1644 }
1645
1646 var (
1647 filter_ABitOfEverythingService_Echo_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
1648 )
1649
1650 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) {
1651 var protoReq sub.StringMessage
1652 var metadata runtime.ServerMetadata
1653
1654 if err := req.ParseForm(); err != nil {
1655 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1656 }
1657 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Echo_2); err != nil {
1658 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1659 }
1660
1661 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1662 return msg, metadata, err
1663
1664 }
1665
1666 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) {
1667 var protoReq sub.StringMessage
1668 var metadata runtime.ServerMetadata
1669
1670 if err := req.ParseForm(); err != nil {
1671 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1672 }
1673 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Echo_2); err != nil {
1674 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1675 }
1676
1677 msg, err := server.Echo(ctx, &protoReq)
1678 return msg, metadata, err
1679
1680 }
1681
1682 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) {
1683 var protoReq ABitOfEverything
1684 var metadata runtime.ServerMetadata
1685
1686 newReader, berr := utilities.IOReaderFactory(req.Body)
1687 if berr != nil {
1688 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1689 }
1690 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
1691 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1692 }
1693
1694 var (
1695 val string
1696 ok bool
1697 err error
1698 _ = err
1699 )
1700
1701 val, ok = pathParams["single_nested.name"]
1702 if !ok {
1703 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
1704 }
1705
1706 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
1707
1708 if err != nil {
1709 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
1710 }
1711
1712 msg, err := client.DeepPathEcho(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1713 return msg, metadata, err
1714
1715 }
1716
1717 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) {
1718 var protoReq ABitOfEverything
1719 var metadata runtime.ServerMetadata
1720
1721 newReader, berr := utilities.IOReaderFactory(req.Body)
1722 if berr != nil {
1723 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1724 }
1725 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
1726 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1727 }
1728
1729 var (
1730 val string
1731 ok bool
1732 err error
1733 _ = err
1734 )
1735
1736 val, ok = pathParams["single_nested.name"]
1737 if !ok {
1738 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
1739 }
1740
1741 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
1742
1743 if err != nil {
1744 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
1745 }
1746
1747 msg, err := server.DeepPathEcho(ctx, &protoReq)
1748 return msg, metadata, err
1749
1750 }
1751
1752 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) {
1753 var protoReq empty.Empty
1754 var metadata runtime.ServerMetadata
1755
1756 msg, err := client.Timeout(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1757 return msg, metadata, err
1758
1759 }
1760
1761 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) {
1762 var protoReq empty.Empty
1763 var metadata runtime.ServerMetadata
1764
1765 msg, err := server.Timeout(ctx, &protoReq)
1766 return msg, metadata, err
1767
1768 }
1769
1770 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) {
1771 var protoReq empty.Empty
1772 var metadata runtime.ServerMetadata
1773
1774 msg, err := client.ErrorWithDetails(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1775 return msg, metadata, err
1776
1777 }
1778
1779 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) {
1780 var protoReq empty.Empty
1781 var metadata runtime.ServerMetadata
1782
1783 msg, err := server.ErrorWithDetails(ctx, &protoReq)
1784 return msg, metadata, err
1785
1786 }
1787
1788 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) {
1789 var protoReq MessageWithBody
1790 var metadata runtime.ServerMetadata
1791
1792 newReader, berr := utilities.IOReaderFactory(req.Body)
1793 if berr != nil {
1794 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1795 }
1796 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Data); err != nil && err != io.EOF {
1797 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1798 }
1799
1800 var (
1801 val string
1802 ok bool
1803 err error
1804 _ = err
1805 )
1806
1807 val, ok = pathParams["id"]
1808 if !ok {
1809 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
1810 }
1811
1812 protoReq.Id, err = runtime.String(val)
1813
1814 if err != nil {
1815 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
1816 }
1817
1818 msg, err := client.GetMessageWithBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1819 return msg, metadata, err
1820
1821 }
1822
1823 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) {
1824 var protoReq MessageWithBody
1825 var metadata runtime.ServerMetadata
1826
1827 newReader, berr := utilities.IOReaderFactory(req.Body)
1828 if berr != nil {
1829 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1830 }
1831 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Data); err != nil && err != io.EOF {
1832 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1833 }
1834
1835 var (
1836 val string
1837 ok bool
1838 err error
1839 _ = err
1840 )
1841
1842 val, ok = pathParams["id"]
1843 if !ok {
1844 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
1845 }
1846
1847 protoReq.Id, err = runtime.String(val)
1848
1849 if err != nil {
1850 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
1851 }
1852
1853 msg, err := server.GetMessageWithBody(ctx, &protoReq)
1854 return msg, metadata, err
1855
1856 }
1857
1858 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) {
1859 var protoReq Body
1860 var metadata runtime.ServerMetadata
1861
1862 newReader, berr := utilities.IOReaderFactory(req.Body)
1863 if berr != nil {
1864 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1865 }
1866 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
1867 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1868 }
1869
1870 var (
1871 val string
1872 ok bool
1873 err error
1874 _ = err
1875 )
1876
1877 val, ok = pathParams["name"]
1878 if !ok {
1879 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
1880 }
1881
1882 protoReq.Name, err = runtime.String(val)
1883
1884 if err != nil {
1885 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
1886 }
1887
1888 msg, err := client.PostWithEmptyBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1889 return msg, metadata, err
1890
1891 }
1892
1893 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) {
1894 var protoReq Body
1895 var metadata runtime.ServerMetadata
1896
1897 newReader, berr := utilities.IOReaderFactory(req.Body)
1898 if berr != nil {
1899 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
1900 }
1901 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
1902 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1903 }
1904
1905 var (
1906 val string
1907 ok bool
1908 err error
1909 _ = err
1910 )
1911
1912 val, ok = pathParams["name"]
1913 if !ok {
1914 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
1915 }
1916
1917 protoReq.Name, err = runtime.String(val)
1918
1919 if err != nil {
1920 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
1921 }
1922
1923 msg, err := server.PostWithEmptyBody(ctx, &protoReq)
1924 return msg, metadata, err
1925
1926 }
1927
1928 var (
1929 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}}
1930 )
1931
1932 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) {
1933 var protoReq ABitOfEverything
1934 var metadata runtime.ServerMetadata
1935
1936 var (
1937 val string
1938 ok bool
1939 err error
1940 _ = err
1941 )
1942
1943 val, ok = pathParams["single_nested.name"]
1944 if !ok {
1945 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
1946 }
1947
1948 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
1949
1950 if err != nil {
1951 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
1952 }
1953
1954 if err := req.ParseForm(); err != nil {
1955 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1956 }
1957 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckGetQueryParams_0); err != nil {
1958 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1959 }
1960
1961 msg, err := client.CheckGetQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
1962 return msg, metadata, err
1963
1964 }
1965
1966 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) {
1967 var protoReq ABitOfEverything
1968 var metadata runtime.ServerMetadata
1969
1970 var (
1971 val string
1972 ok bool
1973 err error
1974 _ = err
1975 )
1976
1977 val, ok = pathParams["single_nested.name"]
1978 if !ok {
1979 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name")
1980 }
1981
1982 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val)
1983
1984 if err != nil {
1985 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err)
1986 }
1987
1988 if err := req.ParseForm(); err != nil {
1989 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1990 }
1991 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckGetQueryParams_0); err != nil {
1992 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1993 }
1994
1995 msg, err := server.CheckGetQueryParams(ctx, &protoReq)
1996 return msg, metadata, err
1997
1998 }
1999
2000 var (
2001 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}}
2002 )
2003
2004 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) {
2005 var protoReq ABitOfEverything
2006 var metadata runtime.ServerMetadata
2007
2008 var (
2009 val string
2010 e int32
2011 ok bool
2012 err error
2013 _ = err
2014 )
2015
2016 val, ok = pathParams["single_nested.ok"]
2017 if !ok {
2018 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.ok")
2019 }
2020
2021 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.ok", val)
2022
2023 e, err = runtime.Enum(val, ABitOfEverything_Nested_DeepEnum_value)
2024
2025 if err != nil {
2026 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.ok", err)
2027 }
2028
2029 protoReq.SingleNested.Ok = ABitOfEverything_Nested_DeepEnum(e)
2030
2031 if err := req.ParseForm(); err != nil {
2032 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2033 }
2034 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0); err != nil {
2035 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2036 }
2037
2038 msg, err := client.CheckNestedEnumGetQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2039 return msg, metadata, err
2040
2041 }
2042
2043 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) {
2044 var protoReq ABitOfEverything
2045 var metadata runtime.ServerMetadata
2046
2047 var (
2048 val string
2049 e int32
2050 ok bool
2051 err error
2052 _ = err
2053 )
2054
2055 val, ok = pathParams["single_nested.ok"]
2056 if !ok {
2057 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.ok")
2058 }
2059
2060 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.ok", val)
2061
2062 e, err = runtime.Enum(val, ABitOfEverything_Nested_DeepEnum_value)
2063
2064 if err != nil {
2065 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.ok", err)
2066 }
2067
2068 protoReq.SingleNested.Ok = ABitOfEverything_Nested_DeepEnum(e)
2069
2070 if err := req.ParseForm(); err != nil {
2071 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2072 }
2073 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0); err != nil {
2074 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2075 }
2076
2077 msg, err := server.CheckNestedEnumGetQueryParams(ctx, &protoReq)
2078 return msg, metadata, err
2079
2080 }
2081
2082 var (
2083 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}}
2084 )
2085
2086 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) {
2087 var protoReq ABitOfEverything
2088 var metadata runtime.ServerMetadata
2089
2090 newReader, berr := utilities.IOReaderFactory(req.Body)
2091 if berr != nil {
2092 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
2093 }
2094 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.SingleNested); err != nil && err != io.EOF {
2095 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2096 }
2097
2098 var (
2099 val string
2100 ok bool
2101 err error
2102 _ = err
2103 )
2104
2105 val, ok = pathParams["string_value"]
2106 if !ok {
2107 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
2108 }
2109
2110 protoReq.StringValue, err = runtime.String(val)
2111
2112 if err != nil {
2113 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
2114 }
2115
2116 if err := req.ParseForm(); err != nil {
2117 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2118 }
2119 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckPostQueryParams_0); err != nil {
2120 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2121 }
2122
2123 msg, err := client.CheckPostQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2124 return msg, metadata, err
2125
2126 }
2127
2128 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) {
2129 var protoReq ABitOfEverything
2130 var metadata runtime.ServerMetadata
2131
2132 newReader, berr := utilities.IOReaderFactory(req.Body)
2133 if berr != nil {
2134 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
2135 }
2136 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.SingleNested); err != nil && err != io.EOF {
2137 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2138 }
2139
2140 var (
2141 val string
2142 ok bool
2143 err error
2144 _ = err
2145 )
2146
2147 val, ok = pathParams["string_value"]
2148 if !ok {
2149 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value")
2150 }
2151
2152 protoReq.StringValue, err = runtime.String(val)
2153
2154 if err != nil {
2155 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err)
2156 }
2157
2158 if err := req.ParseForm(); err != nil {
2159 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2160 }
2161 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckPostQueryParams_0); err != nil {
2162 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
2163 }
2164
2165 msg, err := server.CheckPostQueryParams(ctx, &protoReq)
2166 return msg, metadata, err
2167
2168 }
2169
2170 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) {
2171 var protoReq empty.Empty
2172 var metadata runtime.ServerMetadata
2173
2174 msg, err := client.OverwriteResponseContentType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2175 return msg, metadata, err
2176
2177 }
2178
2179 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) {
2180 var protoReq empty.Empty
2181 var metadata runtime.ServerMetadata
2182
2183 msg, err := server.OverwriteResponseContentType(ctx, &protoReq)
2184 return msg, metadata, err
2185
2186 }
2187
2188 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) {
2189 var protoReq pathenum.MessageWithPathEnum
2190 var metadata runtime.ServerMetadata
2191
2192 var (
2193 val string
2194 e int32
2195 ok bool
2196 err error
2197 _ = err
2198 )
2199
2200 val, ok = pathParams["value"]
2201 if !ok {
2202 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2203 }
2204
2205 e, err = runtime.Enum(val, pathenum.PathEnum_value)
2206
2207 if err != nil {
2208 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2209 }
2210
2211 protoReq.Value = pathenum.PathEnum(e)
2212
2213 msg, err := client.CheckExternalPathEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2214 return msg, metadata, err
2215
2216 }
2217
2218 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) {
2219 var protoReq pathenum.MessageWithPathEnum
2220 var metadata runtime.ServerMetadata
2221
2222 var (
2223 val string
2224 e int32
2225 ok bool
2226 err error
2227 _ = err
2228 )
2229
2230 val, ok = pathParams["value"]
2231 if !ok {
2232 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2233 }
2234
2235 e, err = runtime.Enum(val, pathenum.PathEnum_value)
2236
2237 if err != nil {
2238 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2239 }
2240
2241 protoReq.Value = pathenum.PathEnum(e)
2242
2243 msg, err := server.CheckExternalPathEnum(ctx, &protoReq)
2244 return msg, metadata, err
2245
2246 }
2247
2248 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) {
2249 var protoReq pathenum.MessageWithNestedPathEnum
2250 var metadata runtime.ServerMetadata
2251
2252 var (
2253 val string
2254 e int32
2255 ok bool
2256 err error
2257 _ = err
2258 )
2259
2260 val, ok = pathParams["value"]
2261 if !ok {
2262 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2263 }
2264
2265 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
2266
2267 if err != nil {
2268 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2269 }
2270
2271 protoReq.Value = pathenum.MessagePathEnum_NestedPathEnum(e)
2272
2273 msg, err := client.CheckExternalNestedPathEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2274 return msg, metadata, err
2275
2276 }
2277
2278 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) {
2279 var protoReq pathenum.MessageWithNestedPathEnum
2280 var metadata runtime.ServerMetadata
2281
2282 var (
2283 val string
2284 e int32
2285 ok bool
2286 err error
2287 _ = err
2288 )
2289
2290 val, ok = pathParams["value"]
2291 if !ok {
2292 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value")
2293 }
2294
2295 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value)
2296
2297 if err != nil {
2298 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err)
2299 }
2300
2301 protoReq.Value = pathenum.MessagePathEnum_NestedPathEnum(e)
2302
2303 msg, err := server.CheckExternalNestedPathEnum(ctx, &protoReq)
2304 return msg, metadata, err
2305
2306 }
2307
2308 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) {
2309 var protoReq empty.Empty
2310 var metadata runtime.ServerMetadata
2311
2312 msg, err := client.Empty(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
2313 return msg, metadata, err
2314
2315 }
2316
2317 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) {
2318 var protoReq empty.Empty
2319 var metadata runtime.ServerMetadata
2320
2321 msg, err := server.Empty(ctx, &protoReq)
2322 return msg, metadata, err
2323
2324 }
2325
2326
2327
2328
2329
2330 func RegisterABitOfEverythingServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ABitOfEverythingServiceServer) error {
2331
2332 mux.Handle("POST", pattern_ABitOfEverythingService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2333 ctx, cancel := context.WithCancel(req.Context())
2334 defer cancel()
2335 var stream runtime.ServerTransportStream
2336 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2337 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2338 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2339 if err != nil {
2340 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2341 return
2342 }
2343 resp, md, err := local_request_ABitOfEverythingService_Create_0(rctx, inboundMarshaler, server, req, pathParams)
2344 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2345 ctx = runtime.NewServerMetadataContext(ctx, md)
2346 if err != nil {
2347 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2348 return
2349 }
2350
2351 forward_ABitOfEverythingService_Create_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2352
2353 })
2354
2355 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2356 ctx, cancel := context.WithCancel(req.Context())
2357 defer cancel()
2358 var stream runtime.ServerTransportStream
2359 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2360 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2361 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2362 if err != nil {
2363 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2364 return
2365 }
2366 resp, md, err := local_request_ABitOfEverythingService_CreateBody_0(rctx, inboundMarshaler, server, req, pathParams)
2367 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2368 ctx = runtime.NewServerMetadataContext(ctx, md)
2369 if err != nil {
2370 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2371 return
2372 }
2373
2374 forward_ABitOfEverythingService_CreateBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2375
2376 })
2377
2378 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2379 ctx, cancel := context.WithCancel(req.Context())
2380 defer cancel()
2381 var stream runtime.ServerTransportStream
2382 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2383 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2384 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2385 if err != nil {
2386 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2387 return
2388 }
2389 resp, md, err := local_request_ABitOfEverythingService_CreateBook_0(rctx, inboundMarshaler, server, req, pathParams)
2390 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2391 ctx = runtime.NewServerMetadataContext(ctx, md)
2392 if err != nil {
2393 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2394 return
2395 }
2396
2397 forward_ABitOfEverythingService_CreateBook_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2398
2399 })
2400
2401 mux.Handle("GET", pattern_ABitOfEverythingService_Lookup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2402 ctx, cancel := context.WithCancel(req.Context())
2403 defer cancel()
2404 var stream runtime.ServerTransportStream
2405 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2406 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2407 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2408 if err != nil {
2409 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2410 return
2411 }
2412 resp, md, err := local_request_ABitOfEverythingService_Lookup_0(rctx, inboundMarshaler, server, req, pathParams)
2413 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2414 ctx = runtime.NewServerMetadataContext(ctx, md)
2415 if err != nil {
2416 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2417 return
2418 }
2419
2420 forward_ABitOfEverythingService_Lookup_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2421
2422 })
2423
2424 mux.Handle("PUT", pattern_ABitOfEverythingService_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2425 ctx, cancel := context.WithCancel(req.Context())
2426 defer cancel()
2427 var stream runtime.ServerTransportStream
2428 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2429 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2430 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2431 if err != nil {
2432 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2433 return
2434 }
2435 resp, md, err := local_request_ABitOfEverythingService_Update_0(rctx, inboundMarshaler, server, req, pathParams)
2436 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2437 ctx = runtime.NewServerMetadataContext(ctx, md)
2438 if err != nil {
2439 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2440 return
2441 }
2442
2443 forward_ABitOfEverythingService_Update_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2444
2445 })
2446
2447 mux.Handle("PUT", pattern_ABitOfEverythingService_UpdateV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2448 ctx, cancel := context.WithCancel(req.Context())
2449 defer cancel()
2450 var stream runtime.ServerTransportStream
2451 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2452 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2453 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2454 if err != nil {
2455 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2456 return
2457 }
2458 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_0(rctx, inboundMarshaler, server, req, pathParams)
2459 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2460 ctx = runtime.NewServerMetadataContext(ctx, md)
2461 if err != nil {
2462 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2463 return
2464 }
2465
2466 forward_ABitOfEverythingService_UpdateV2_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2467
2468 })
2469
2470 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2471 ctx, cancel := context.WithCancel(req.Context())
2472 defer cancel()
2473 var stream runtime.ServerTransportStream
2474 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2475 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2476 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2477 if err != nil {
2478 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2479 return
2480 }
2481 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_1(rctx, inboundMarshaler, server, req, pathParams)
2482 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2483 ctx = runtime.NewServerMetadataContext(ctx, md)
2484 if err != nil {
2485 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2486 return
2487 }
2488
2489 forward_ABitOfEverythingService_UpdateV2_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2490
2491 })
2492
2493 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2494 ctx, cancel := context.WithCancel(req.Context())
2495 defer cancel()
2496 var stream runtime.ServerTransportStream
2497 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2498 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2499 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2500 if err != nil {
2501 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2502 return
2503 }
2504 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_2(rctx, inboundMarshaler, server, req, pathParams)
2505 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2506 ctx = runtime.NewServerMetadataContext(ctx, md)
2507 if err != nil {
2508 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2509 return
2510 }
2511
2512 forward_ABitOfEverythingService_UpdateV2_2(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2513
2514 })
2515
2516 mux.Handle("DELETE", pattern_ABitOfEverythingService_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2517 ctx, cancel := context.WithCancel(req.Context())
2518 defer cancel()
2519 var stream runtime.ServerTransportStream
2520 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2521 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2522 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2523 if err != nil {
2524 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2525 return
2526 }
2527 resp, md, err := local_request_ABitOfEverythingService_Delete_0(rctx, inboundMarshaler, server, req, pathParams)
2528 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2529 ctx = runtime.NewServerMetadataContext(ctx, md)
2530 if err != nil {
2531 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2532 return
2533 }
2534
2535 forward_ABitOfEverythingService_Delete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2536
2537 })
2538
2539 mux.Handle("GET", pattern_ABitOfEverythingService_GetQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2540 ctx, cancel := context.WithCancel(req.Context())
2541 defer cancel()
2542 var stream runtime.ServerTransportStream
2543 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2544 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2545 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2546 if err != nil {
2547 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2548 return
2549 }
2550 resp, md, err := local_request_ABitOfEverythingService_GetQuery_0(rctx, inboundMarshaler, server, req, pathParams)
2551 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2552 ctx = runtime.NewServerMetadataContext(ctx, md)
2553 if err != nil {
2554 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2555 return
2556 }
2557
2558 forward_ABitOfEverythingService_GetQuery_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2559
2560 })
2561
2562 mux.Handle("GET", pattern_ABitOfEverythingService_GetRepeatedQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2563 ctx, cancel := context.WithCancel(req.Context())
2564 defer cancel()
2565 var stream runtime.ServerTransportStream
2566 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2567 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2568 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2569 if err != nil {
2570 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2571 return
2572 }
2573 resp, md, err := local_request_ABitOfEverythingService_GetRepeatedQuery_0(rctx, inboundMarshaler, server, req, pathParams)
2574 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2575 ctx = runtime.NewServerMetadataContext(ctx, md)
2576 if err != nil {
2577 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2578 return
2579 }
2580
2581 forward_ABitOfEverythingService_GetRepeatedQuery_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2582
2583 })
2584
2585 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2586 ctx, cancel := context.WithCancel(req.Context())
2587 defer cancel()
2588 var stream runtime.ServerTransportStream
2589 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2590 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2591 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2592 if err != nil {
2593 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2594 return
2595 }
2596 resp, md, err := local_request_ABitOfEverythingService_Echo_0(rctx, inboundMarshaler, server, req, pathParams)
2597 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2598 ctx = runtime.NewServerMetadataContext(ctx, md)
2599 if err != nil {
2600 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2601 return
2602 }
2603
2604 forward_ABitOfEverythingService_Echo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2605
2606 })
2607
2608 mux.Handle("POST", pattern_ABitOfEverythingService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2609 ctx, cancel := context.WithCancel(req.Context())
2610 defer cancel()
2611 var stream runtime.ServerTransportStream
2612 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2613 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2614 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2615 if err != nil {
2616 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2617 return
2618 }
2619 resp, md, err := local_request_ABitOfEverythingService_Echo_1(rctx, inboundMarshaler, server, req, pathParams)
2620 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2621 ctx = runtime.NewServerMetadataContext(ctx, md)
2622 if err != nil {
2623 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2624 return
2625 }
2626
2627 forward_ABitOfEverythingService_Echo_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2628
2629 })
2630
2631 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2632 ctx, cancel := context.WithCancel(req.Context())
2633 defer cancel()
2634 var stream runtime.ServerTransportStream
2635 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2636 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2637 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2638 if err != nil {
2639 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2640 return
2641 }
2642 resp, md, err := local_request_ABitOfEverythingService_Echo_2(rctx, inboundMarshaler, server, req, pathParams)
2643 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2644 ctx = runtime.NewServerMetadataContext(ctx, md)
2645 if err != nil {
2646 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2647 return
2648 }
2649
2650 forward_ABitOfEverythingService_Echo_2(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2651
2652 })
2653
2654 mux.Handle("POST", pattern_ABitOfEverythingService_DeepPathEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2655 ctx, cancel := context.WithCancel(req.Context())
2656 defer cancel()
2657 var stream runtime.ServerTransportStream
2658 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2659 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2660 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2661 if err != nil {
2662 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2663 return
2664 }
2665 resp, md, err := local_request_ABitOfEverythingService_DeepPathEcho_0(rctx, inboundMarshaler, server, req, pathParams)
2666 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2667 ctx = runtime.NewServerMetadataContext(ctx, md)
2668 if err != nil {
2669 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2670 return
2671 }
2672
2673 forward_ABitOfEverythingService_DeepPathEcho_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2674
2675 })
2676
2677 mux.Handle("GET", pattern_ABitOfEverythingService_Timeout_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2678 ctx, cancel := context.WithCancel(req.Context())
2679 defer cancel()
2680 var stream runtime.ServerTransportStream
2681 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2682 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2683 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2684 if err != nil {
2685 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2686 return
2687 }
2688 resp, md, err := local_request_ABitOfEverythingService_Timeout_0(rctx, inboundMarshaler, server, req, pathParams)
2689 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2690 ctx = runtime.NewServerMetadataContext(ctx, md)
2691 if err != nil {
2692 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2693 return
2694 }
2695
2696 forward_ABitOfEverythingService_Timeout_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2697
2698 })
2699
2700 mux.Handle("GET", pattern_ABitOfEverythingService_ErrorWithDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2701 ctx, cancel := context.WithCancel(req.Context())
2702 defer cancel()
2703 var stream runtime.ServerTransportStream
2704 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2705 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2706 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2707 if err != nil {
2708 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2709 return
2710 }
2711 resp, md, err := local_request_ABitOfEverythingService_ErrorWithDetails_0(rctx, inboundMarshaler, server, req, pathParams)
2712 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2713 ctx = runtime.NewServerMetadataContext(ctx, md)
2714 if err != nil {
2715 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2716 return
2717 }
2718
2719 forward_ABitOfEverythingService_ErrorWithDetails_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2720
2721 })
2722
2723 mux.Handle("POST", pattern_ABitOfEverythingService_GetMessageWithBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2724 ctx, cancel := context.WithCancel(req.Context())
2725 defer cancel()
2726 var stream runtime.ServerTransportStream
2727 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2728 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2729 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2730 if err != nil {
2731 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2732 return
2733 }
2734 resp, md, err := local_request_ABitOfEverythingService_GetMessageWithBody_0(rctx, inboundMarshaler, server, req, pathParams)
2735 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2736 ctx = runtime.NewServerMetadataContext(ctx, md)
2737 if err != nil {
2738 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2739 return
2740 }
2741
2742 forward_ABitOfEverythingService_GetMessageWithBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2743
2744 })
2745
2746 mux.Handle("POST", pattern_ABitOfEverythingService_PostWithEmptyBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2747 ctx, cancel := context.WithCancel(req.Context())
2748 defer cancel()
2749 var stream runtime.ServerTransportStream
2750 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2751 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2752 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2753 if err != nil {
2754 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2755 return
2756 }
2757 resp, md, err := local_request_ABitOfEverythingService_PostWithEmptyBody_0(rctx, inboundMarshaler, server, req, pathParams)
2758 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2759 ctx = runtime.NewServerMetadataContext(ctx, md)
2760 if err != nil {
2761 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2762 return
2763 }
2764
2765 forward_ABitOfEverythingService_PostWithEmptyBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2766
2767 })
2768
2769 mux.Handle("GET", pattern_ABitOfEverythingService_CheckGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2770 ctx, cancel := context.WithCancel(req.Context())
2771 defer cancel()
2772 var stream runtime.ServerTransportStream
2773 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2774 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2775 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2776 if err != nil {
2777 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2778 return
2779 }
2780 resp, md, err := local_request_ABitOfEverythingService_CheckGetQueryParams_0(rctx, inboundMarshaler, server, req, pathParams)
2781 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2782 ctx = runtime.NewServerMetadataContext(ctx, md)
2783 if err != nil {
2784 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2785 return
2786 }
2787
2788 forward_ABitOfEverythingService_CheckGetQueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2789
2790 })
2791
2792 mux.Handle("GET", pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2793 ctx, cancel := context.WithCancel(req.Context())
2794 defer cancel()
2795 var stream runtime.ServerTransportStream
2796 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2797 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2798 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2799 if err != nil {
2800 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2801 return
2802 }
2803 resp, md, err := local_request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(rctx, inboundMarshaler, server, req, pathParams)
2804 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2805 ctx = runtime.NewServerMetadataContext(ctx, md)
2806 if err != nil {
2807 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2808 return
2809 }
2810
2811 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2812
2813 })
2814
2815 mux.Handle("POST", pattern_ABitOfEverythingService_CheckPostQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2816 ctx, cancel := context.WithCancel(req.Context())
2817 defer cancel()
2818 var stream runtime.ServerTransportStream
2819 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2820 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2821 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2822 if err != nil {
2823 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2824 return
2825 }
2826 resp, md, err := local_request_ABitOfEverythingService_CheckPostQueryParams_0(rctx, inboundMarshaler, server, req, pathParams)
2827 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2828 ctx = runtime.NewServerMetadataContext(ctx, md)
2829 if err != nil {
2830 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2831 return
2832 }
2833
2834 forward_ABitOfEverythingService_CheckPostQueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2835
2836 })
2837
2838 mux.Handle("GET", pattern_ABitOfEverythingService_OverwriteResponseContentType_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 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2845 if err != nil {
2846 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2847 return
2848 }
2849 resp, md, err := local_request_ABitOfEverythingService_OverwriteResponseContentType_0(rctx, inboundMarshaler, server, req, pathParams)
2850 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2851 ctx = runtime.NewServerMetadataContext(ctx, md)
2852 if err != nil {
2853 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2854 return
2855 }
2856
2857 forward_ABitOfEverythingService_OverwriteResponseContentType_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2858
2859 })
2860
2861 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2862 ctx, cancel := context.WithCancel(req.Context())
2863 defer cancel()
2864 var stream runtime.ServerTransportStream
2865 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2866 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2867 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2868 if err != nil {
2869 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2870 return
2871 }
2872 resp, md, err := local_request_ABitOfEverythingService_CheckExternalPathEnum_0(rctx, inboundMarshaler, server, req, pathParams)
2873 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2874 ctx = runtime.NewServerMetadataContext(ctx, md)
2875 if err != nil {
2876 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2877 return
2878 }
2879
2880 forward_ABitOfEverythingService_CheckExternalPathEnum_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2881
2882 })
2883
2884 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2885 ctx, cancel := context.WithCancel(req.Context())
2886 defer cancel()
2887 var stream runtime.ServerTransportStream
2888 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2889 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2890 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2891 if err != nil {
2892 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2893 return
2894 }
2895 resp, md, err := local_request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(rctx, inboundMarshaler, server, req, pathParams)
2896 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2897 ctx = runtime.NewServerMetadataContext(ctx, md)
2898 if err != nil {
2899 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2900 return
2901 }
2902
2903 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2904
2905 })
2906
2907 return nil
2908 }
2909
2910
2911
2912
2913
2914 func RegisterCamelCaseServiceNameHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CamelCaseServiceNameServer) error {
2915
2916 mux.Handle("GET", pattern_CamelCaseServiceName_Empty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2917 ctx, cancel := context.WithCancel(req.Context())
2918 defer cancel()
2919 var stream runtime.ServerTransportStream
2920 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
2921 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2922 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
2923 if err != nil {
2924 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2925 return
2926 }
2927 resp, md, err := local_request_CamelCaseServiceName_Empty_0(rctx, inboundMarshaler, server, req, pathParams)
2928 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
2929 ctx = runtime.NewServerMetadataContext(ctx, md)
2930 if err != nil {
2931 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2932 return
2933 }
2934
2935 forward_CamelCaseServiceName_Empty_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2936
2937 })
2938
2939 return nil
2940 }
2941
2942
2943
2944 func RegisterABitOfEverythingServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
2945 conn, err := grpc.Dial(endpoint, opts...)
2946 if err != nil {
2947 return err
2948 }
2949 defer func() {
2950 if err != nil {
2951 if cerr := conn.Close(); cerr != nil {
2952 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
2953 }
2954 return
2955 }
2956 go func() {
2957 <-ctx.Done()
2958 if cerr := conn.Close(); cerr != nil {
2959 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
2960 }
2961 }()
2962 }()
2963
2964 return RegisterABitOfEverythingServiceHandler(ctx, mux, conn)
2965 }
2966
2967
2968
2969 func RegisterABitOfEverythingServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
2970 return RegisterABitOfEverythingServiceHandlerClient(ctx, mux, NewABitOfEverythingServiceClient(conn))
2971 }
2972
2973
2974
2975
2976
2977
2978 func RegisterABitOfEverythingServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ABitOfEverythingServiceClient) error {
2979
2980 mux.Handle("POST", pattern_ABitOfEverythingService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2981 ctx, cancel := context.WithCancel(req.Context())
2982 defer cancel()
2983 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2984 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2985 if err != nil {
2986 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2987 return
2988 }
2989 resp, md, err := request_ABitOfEverythingService_Create_0(rctx, inboundMarshaler, client, req, pathParams)
2990 ctx = runtime.NewServerMetadataContext(ctx, md)
2991 if err != nil {
2992 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2993 return
2994 }
2995
2996 forward_ABitOfEverythingService_Create_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2997
2998 })
2999
3000 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3001 ctx, cancel := context.WithCancel(req.Context())
3002 defer cancel()
3003 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3004 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3005 if err != nil {
3006 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3007 return
3008 }
3009 resp, md, err := request_ABitOfEverythingService_CreateBody_0(rctx, inboundMarshaler, client, req, pathParams)
3010 ctx = runtime.NewServerMetadataContext(ctx, md)
3011 if err != nil {
3012 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3013 return
3014 }
3015
3016 forward_ABitOfEverythingService_CreateBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3017
3018 })
3019
3020 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3021 ctx, cancel := context.WithCancel(req.Context())
3022 defer cancel()
3023 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3024 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3025 if err != nil {
3026 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3027 return
3028 }
3029 resp, md, err := request_ABitOfEverythingService_CreateBook_0(rctx, inboundMarshaler, client, req, pathParams)
3030 ctx = runtime.NewServerMetadataContext(ctx, md)
3031 if err != nil {
3032 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3033 return
3034 }
3035
3036 forward_ABitOfEverythingService_CreateBook_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3037
3038 })
3039
3040 mux.Handle("GET", pattern_ABitOfEverythingService_Lookup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3041 ctx, cancel := context.WithCancel(req.Context())
3042 defer cancel()
3043 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3044 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3045 if err != nil {
3046 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3047 return
3048 }
3049 resp, md, err := request_ABitOfEverythingService_Lookup_0(rctx, inboundMarshaler, client, req, pathParams)
3050 ctx = runtime.NewServerMetadataContext(ctx, md)
3051 if err != nil {
3052 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3053 return
3054 }
3055
3056 forward_ABitOfEverythingService_Lookup_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3057
3058 })
3059
3060 mux.Handle("PUT", pattern_ABitOfEverythingService_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3061 ctx, cancel := context.WithCancel(req.Context())
3062 defer cancel()
3063 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3064 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3065 if err != nil {
3066 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3067 return
3068 }
3069 resp, md, err := request_ABitOfEverythingService_Update_0(rctx, inboundMarshaler, client, req, pathParams)
3070 ctx = runtime.NewServerMetadataContext(ctx, md)
3071 if err != nil {
3072 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3073 return
3074 }
3075
3076 forward_ABitOfEverythingService_Update_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3077
3078 })
3079
3080 mux.Handle("PUT", pattern_ABitOfEverythingService_UpdateV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3081 ctx, cancel := context.WithCancel(req.Context())
3082 defer cancel()
3083 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3084 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3085 if err != nil {
3086 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3087 return
3088 }
3089 resp, md, err := request_ABitOfEverythingService_UpdateV2_0(rctx, inboundMarshaler, client, req, pathParams)
3090 ctx = runtime.NewServerMetadataContext(ctx, md)
3091 if err != nil {
3092 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3093 return
3094 }
3095
3096 forward_ABitOfEverythingService_UpdateV2_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3097
3098 })
3099
3100 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3101 ctx, cancel := context.WithCancel(req.Context())
3102 defer cancel()
3103 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3104 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3105 if err != nil {
3106 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3107 return
3108 }
3109 resp, md, err := request_ABitOfEverythingService_UpdateV2_1(rctx, inboundMarshaler, client, req, pathParams)
3110 ctx = runtime.NewServerMetadataContext(ctx, md)
3111 if err != nil {
3112 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3113 return
3114 }
3115
3116 forward_ABitOfEverythingService_UpdateV2_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3117
3118 })
3119
3120 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3121 ctx, cancel := context.WithCancel(req.Context())
3122 defer cancel()
3123 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3124 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3125 if err != nil {
3126 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3127 return
3128 }
3129 resp, md, err := request_ABitOfEverythingService_UpdateV2_2(rctx, inboundMarshaler, client, req, pathParams)
3130 ctx = runtime.NewServerMetadataContext(ctx, md)
3131 if err != nil {
3132 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3133 return
3134 }
3135
3136 forward_ABitOfEverythingService_UpdateV2_2(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3137
3138 })
3139
3140 mux.Handle("DELETE", pattern_ABitOfEverythingService_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3141 ctx, cancel := context.WithCancel(req.Context())
3142 defer cancel()
3143 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3144 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3145 if err != nil {
3146 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3147 return
3148 }
3149 resp, md, err := request_ABitOfEverythingService_Delete_0(rctx, inboundMarshaler, client, req, pathParams)
3150 ctx = runtime.NewServerMetadataContext(ctx, md)
3151 if err != nil {
3152 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3153 return
3154 }
3155
3156 forward_ABitOfEverythingService_Delete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3157
3158 })
3159
3160 mux.Handle("GET", pattern_ABitOfEverythingService_GetQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3161 ctx, cancel := context.WithCancel(req.Context())
3162 defer cancel()
3163 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3164 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3165 if err != nil {
3166 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3167 return
3168 }
3169 resp, md, err := request_ABitOfEverythingService_GetQuery_0(rctx, inboundMarshaler, client, req, pathParams)
3170 ctx = runtime.NewServerMetadataContext(ctx, md)
3171 if err != nil {
3172 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3173 return
3174 }
3175
3176 forward_ABitOfEverythingService_GetQuery_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3177
3178 })
3179
3180 mux.Handle("GET", pattern_ABitOfEverythingService_GetRepeatedQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3181 ctx, cancel := context.WithCancel(req.Context())
3182 defer cancel()
3183 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3184 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3185 if err != nil {
3186 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3187 return
3188 }
3189 resp, md, err := request_ABitOfEverythingService_GetRepeatedQuery_0(rctx, inboundMarshaler, client, req, pathParams)
3190 ctx = runtime.NewServerMetadataContext(ctx, md)
3191 if err != nil {
3192 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3193 return
3194 }
3195
3196 forward_ABitOfEverythingService_GetRepeatedQuery_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3197
3198 })
3199
3200 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3201 ctx, cancel := context.WithCancel(req.Context())
3202 defer cancel()
3203 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3204 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3205 if err != nil {
3206 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3207 return
3208 }
3209 resp, md, err := request_ABitOfEverythingService_Echo_0(rctx, inboundMarshaler, client, req, pathParams)
3210 ctx = runtime.NewServerMetadataContext(ctx, md)
3211 if err != nil {
3212 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3213 return
3214 }
3215
3216 forward_ABitOfEverythingService_Echo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3217
3218 })
3219
3220 mux.Handle("POST", pattern_ABitOfEverythingService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3221 ctx, cancel := context.WithCancel(req.Context())
3222 defer cancel()
3223 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3224 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3225 if err != nil {
3226 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3227 return
3228 }
3229 resp, md, err := request_ABitOfEverythingService_Echo_1(rctx, inboundMarshaler, client, req, pathParams)
3230 ctx = runtime.NewServerMetadataContext(ctx, md)
3231 if err != nil {
3232 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3233 return
3234 }
3235
3236 forward_ABitOfEverythingService_Echo_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3237
3238 })
3239
3240 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3241 ctx, cancel := context.WithCancel(req.Context())
3242 defer cancel()
3243 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3244 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3245 if err != nil {
3246 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3247 return
3248 }
3249 resp, md, err := request_ABitOfEverythingService_Echo_2(rctx, inboundMarshaler, client, req, pathParams)
3250 ctx = runtime.NewServerMetadataContext(ctx, md)
3251 if err != nil {
3252 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3253 return
3254 }
3255
3256 forward_ABitOfEverythingService_Echo_2(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3257
3258 })
3259
3260 mux.Handle("POST", pattern_ABitOfEverythingService_DeepPathEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3261 ctx, cancel := context.WithCancel(req.Context())
3262 defer cancel()
3263 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3264 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3265 if err != nil {
3266 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3267 return
3268 }
3269 resp, md, err := request_ABitOfEverythingService_DeepPathEcho_0(rctx, inboundMarshaler, client, req, pathParams)
3270 ctx = runtime.NewServerMetadataContext(ctx, md)
3271 if err != nil {
3272 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3273 return
3274 }
3275
3276 forward_ABitOfEverythingService_DeepPathEcho_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3277
3278 })
3279
3280 mux.Handle("GET", pattern_ABitOfEverythingService_Timeout_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3281 ctx, cancel := context.WithCancel(req.Context())
3282 defer cancel()
3283 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3284 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3285 if err != nil {
3286 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3287 return
3288 }
3289 resp, md, err := request_ABitOfEverythingService_Timeout_0(rctx, inboundMarshaler, client, req, pathParams)
3290 ctx = runtime.NewServerMetadataContext(ctx, md)
3291 if err != nil {
3292 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3293 return
3294 }
3295
3296 forward_ABitOfEverythingService_Timeout_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3297
3298 })
3299
3300 mux.Handle("GET", pattern_ABitOfEverythingService_ErrorWithDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3301 ctx, cancel := context.WithCancel(req.Context())
3302 defer cancel()
3303 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3304 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3305 if err != nil {
3306 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3307 return
3308 }
3309 resp, md, err := request_ABitOfEverythingService_ErrorWithDetails_0(rctx, inboundMarshaler, client, req, pathParams)
3310 ctx = runtime.NewServerMetadataContext(ctx, md)
3311 if err != nil {
3312 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3313 return
3314 }
3315
3316 forward_ABitOfEverythingService_ErrorWithDetails_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3317
3318 })
3319
3320 mux.Handle("POST", pattern_ABitOfEverythingService_GetMessageWithBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3321 ctx, cancel := context.WithCancel(req.Context())
3322 defer cancel()
3323 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3324 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3325 if err != nil {
3326 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3327 return
3328 }
3329 resp, md, err := request_ABitOfEverythingService_GetMessageWithBody_0(rctx, inboundMarshaler, client, req, pathParams)
3330 ctx = runtime.NewServerMetadataContext(ctx, md)
3331 if err != nil {
3332 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3333 return
3334 }
3335
3336 forward_ABitOfEverythingService_GetMessageWithBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3337
3338 })
3339
3340 mux.Handle("POST", pattern_ABitOfEverythingService_PostWithEmptyBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3341 ctx, cancel := context.WithCancel(req.Context())
3342 defer cancel()
3343 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3344 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3345 if err != nil {
3346 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3347 return
3348 }
3349 resp, md, err := request_ABitOfEverythingService_PostWithEmptyBody_0(rctx, inboundMarshaler, client, req, pathParams)
3350 ctx = runtime.NewServerMetadataContext(ctx, md)
3351 if err != nil {
3352 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3353 return
3354 }
3355
3356 forward_ABitOfEverythingService_PostWithEmptyBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3357
3358 })
3359
3360 mux.Handle("GET", pattern_ABitOfEverythingService_CheckGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3361 ctx, cancel := context.WithCancel(req.Context())
3362 defer cancel()
3363 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3364 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3365 if err != nil {
3366 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3367 return
3368 }
3369 resp, md, err := request_ABitOfEverythingService_CheckGetQueryParams_0(rctx, inboundMarshaler, client, req, pathParams)
3370 ctx = runtime.NewServerMetadataContext(ctx, md)
3371 if err != nil {
3372 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3373 return
3374 }
3375
3376 forward_ABitOfEverythingService_CheckGetQueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3377
3378 })
3379
3380 mux.Handle("GET", pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3381 ctx, cancel := context.WithCancel(req.Context())
3382 defer cancel()
3383 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3384 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3385 if err != nil {
3386 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3387 return
3388 }
3389 resp, md, err := request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(rctx, inboundMarshaler, client, req, pathParams)
3390 ctx = runtime.NewServerMetadataContext(ctx, md)
3391 if err != nil {
3392 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3393 return
3394 }
3395
3396 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3397
3398 })
3399
3400 mux.Handle("POST", pattern_ABitOfEverythingService_CheckPostQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3401 ctx, cancel := context.WithCancel(req.Context())
3402 defer cancel()
3403 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3404 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3405 if err != nil {
3406 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3407 return
3408 }
3409 resp, md, err := request_ABitOfEverythingService_CheckPostQueryParams_0(rctx, inboundMarshaler, client, req, pathParams)
3410 ctx = runtime.NewServerMetadataContext(ctx, md)
3411 if err != nil {
3412 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3413 return
3414 }
3415
3416 forward_ABitOfEverythingService_CheckPostQueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3417
3418 })
3419
3420 mux.Handle("GET", pattern_ABitOfEverythingService_OverwriteResponseContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3421 ctx, cancel := context.WithCancel(req.Context())
3422 defer cancel()
3423 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3424 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3425 if err != nil {
3426 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3427 return
3428 }
3429 resp, md, err := request_ABitOfEverythingService_OverwriteResponseContentType_0(rctx, inboundMarshaler, client, req, pathParams)
3430 ctx = runtime.NewServerMetadataContext(ctx, md)
3431 if err != nil {
3432 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3433 return
3434 }
3435
3436 forward_ABitOfEverythingService_OverwriteResponseContentType_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3437
3438 })
3439
3440 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3441 ctx, cancel := context.WithCancel(req.Context())
3442 defer cancel()
3443 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3444 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3445 if err != nil {
3446 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3447 return
3448 }
3449 resp, md, err := request_ABitOfEverythingService_CheckExternalPathEnum_0(rctx, inboundMarshaler, client, req, pathParams)
3450 ctx = runtime.NewServerMetadataContext(ctx, md)
3451 if err != nil {
3452 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3453 return
3454 }
3455
3456 forward_ABitOfEverythingService_CheckExternalPathEnum_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3457
3458 })
3459
3460 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3461 ctx, cancel := context.WithCancel(req.Context())
3462 defer cancel()
3463 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3464 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3465 if err != nil {
3466 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3467 return
3468 }
3469 resp, md, err := request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(rctx, inboundMarshaler, client, req, pathParams)
3470 ctx = runtime.NewServerMetadataContext(ctx, md)
3471 if err != nil {
3472 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3473 return
3474 }
3475
3476 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3477
3478 })
3479
3480 return nil
3481 }
3482
3483 var (
3484 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"}, "", runtime.AssumeColonVerbOpt(true)))
3485
3486 pattern_ABitOfEverythingService_CreateBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "a_bit_of_everything"}, "", runtime.AssumeColonVerbOpt(true)))
3487
3488 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"}, "", runtime.AssumeColonVerbOpt(true)))
3489
3490 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"}, "", runtime.AssumeColonVerbOpt(true)))
3491
3492 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"}, "", runtime.AssumeColonVerbOpt(true)))
3493
3494 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"}, "", runtime.AssumeColonVerbOpt(true)))
3495
3496 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"}, "", runtime.AssumeColonVerbOpt(true)))
3497
3498 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"}, "", runtime.AssumeColonVerbOpt(true)))
3499
3500 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"}, "", runtime.AssumeColonVerbOpt(true)))
3501
3502 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"}, "", runtime.AssumeColonVerbOpt(true)))
3503
3504 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"}, "", runtime.AssumeColonVerbOpt(true)))
3505
3506 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"}, "", runtime.AssumeColonVerbOpt(true)))
3507
3508 pattern_ABitOfEverythingService_Echo_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "echo"}, "", runtime.AssumeColonVerbOpt(true)))
3509
3510 pattern_ABitOfEverythingService_Echo_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "echo"}, "", runtime.AssumeColonVerbOpt(true)))
3511
3512 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", "a_bit_of_everything", "single_nested.name"}, "", runtime.AssumeColonVerbOpt(true)))
3513
3514 pattern_ABitOfEverythingService_Timeout_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "timeout"}, "", runtime.AssumeColonVerbOpt(true)))
3515
3516 pattern_ABitOfEverythingService_ErrorWithDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "errorwithdetails"}, "", runtime.AssumeColonVerbOpt(true)))
3517
3518 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"}, "", runtime.AssumeColonVerbOpt(true)))
3519
3520 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"}, "", runtime.AssumeColonVerbOpt(true)))
3521
3522 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"}, "", runtime.AssumeColonVerbOpt(true)))
3523
3524 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"}, "", runtime.AssumeColonVerbOpt(true)))
3525
3526 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"}, "", runtime.AssumeColonVerbOpt(true)))
3527
3528 pattern_ABitOfEverythingService_OverwriteResponseContentType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "overwriteresponsecontenttype"}, "", runtime.AssumeColonVerbOpt(true)))
3529
3530 pattern_ABitOfEverythingService_CheckExternalPathEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"v2", "value"}, "check", runtime.AssumeColonVerbOpt(true)))
3531
3532 pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"v2", "value"}, "check", runtime.AssumeColonVerbOpt(true)))
3533 )
3534
3535 var (
3536 forward_ABitOfEverythingService_Create_0 = runtime.ForwardResponseMessage
3537
3538 forward_ABitOfEverythingService_CreateBody_0 = runtime.ForwardResponseMessage
3539
3540 forward_ABitOfEverythingService_CreateBook_0 = runtime.ForwardResponseMessage
3541
3542 forward_ABitOfEverythingService_Lookup_0 = runtime.ForwardResponseMessage
3543
3544 forward_ABitOfEverythingService_Update_0 = runtime.ForwardResponseMessage
3545
3546 forward_ABitOfEverythingService_UpdateV2_0 = runtime.ForwardResponseMessage
3547
3548 forward_ABitOfEverythingService_UpdateV2_1 = runtime.ForwardResponseMessage
3549
3550 forward_ABitOfEverythingService_UpdateV2_2 = runtime.ForwardResponseMessage
3551
3552 forward_ABitOfEverythingService_Delete_0 = runtime.ForwardResponseMessage
3553
3554 forward_ABitOfEverythingService_GetQuery_0 = runtime.ForwardResponseMessage
3555
3556 forward_ABitOfEverythingService_GetRepeatedQuery_0 = runtime.ForwardResponseMessage
3557
3558 forward_ABitOfEverythingService_Echo_0 = runtime.ForwardResponseMessage
3559
3560 forward_ABitOfEverythingService_Echo_1 = runtime.ForwardResponseMessage
3561
3562 forward_ABitOfEverythingService_Echo_2 = runtime.ForwardResponseMessage
3563
3564 forward_ABitOfEverythingService_DeepPathEcho_0 = runtime.ForwardResponseMessage
3565
3566 forward_ABitOfEverythingService_Timeout_0 = runtime.ForwardResponseMessage
3567
3568 forward_ABitOfEverythingService_ErrorWithDetails_0 = runtime.ForwardResponseMessage
3569
3570 forward_ABitOfEverythingService_GetMessageWithBody_0 = runtime.ForwardResponseMessage
3571
3572 forward_ABitOfEverythingService_PostWithEmptyBody_0 = runtime.ForwardResponseMessage
3573
3574 forward_ABitOfEverythingService_CheckGetQueryParams_0 = runtime.ForwardResponseMessage
3575
3576 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = runtime.ForwardResponseMessage
3577
3578 forward_ABitOfEverythingService_CheckPostQueryParams_0 = runtime.ForwardResponseMessage
3579
3580 forward_ABitOfEverythingService_OverwriteResponseContentType_0 = runtime.ForwardResponseMessage
3581
3582 forward_ABitOfEverythingService_CheckExternalPathEnum_0 = runtime.ForwardResponseMessage
3583
3584 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0 = runtime.ForwardResponseMessage
3585 )
3586
3587
3588
3589 func RegisterCamelCaseServiceNameHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
3590 conn, err := grpc.Dial(endpoint, opts...)
3591 if err != nil {
3592 return err
3593 }
3594 defer func() {
3595 if err != nil {
3596 if cerr := conn.Close(); cerr != nil {
3597 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
3598 }
3599 return
3600 }
3601 go func() {
3602 <-ctx.Done()
3603 if cerr := conn.Close(); cerr != nil {
3604 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
3605 }
3606 }()
3607 }()
3608
3609 return RegisterCamelCaseServiceNameHandler(ctx, mux, conn)
3610 }
3611
3612
3613
3614 func RegisterCamelCaseServiceNameHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
3615 return RegisterCamelCaseServiceNameHandlerClient(ctx, mux, NewCamelCaseServiceNameClient(conn))
3616 }
3617
3618
3619
3620
3621
3622
3623 func RegisterCamelCaseServiceNameHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CamelCaseServiceNameClient) error {
3624
3625 mux.Handle("GET", pattern_CamelCaseServiceName_Empty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
3626 ctx, cancel := context.WithCancel(req.Context())
3627 defer cancel()
3628 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
3629 rctx, err := runtime.AnnotateContext(ctx, mux, req)
3630 if err != nil {
3631 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3632 return
3633 }
3634 resp, md, err := request_CamelCaseServiceName_Empty_0(rctx, inboundMarshaler, client, req, pathParams)
3635 ctx = runtime.NewServerMetadataContext(ctx, md)
3636 if err != nil {
3637 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
3638 return
3639 }
3640
3641 forward_CamelCaseServiceName_Empty_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
3642
3643 })
3644
3645 return nil
3646 }
3647
3648 var (
3649 pattern_CamelCaseServiceName_Empty_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "empty"}, "", runtime.AssumeColonVerbOpt(true)))
3650 )
3651
3652 var (
3653 forward_CamelCaseServiceName_Empty_0 = runtime.ForwardResponseMessage
3654 )
3655
View as plain text