1
2
3
4
9 package helloworld
10
11 import (
12 "context"
13 "io"
14 "net/http"
15
16 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
17 "github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
18 "google.golang.org/grpc"
19 "google.golang.org/grpc/codes"
20 "google.golang.org/grpc/grpclog"
21 "google.golang.org/grpc/metadata"
22 "google.golang.org/grpc/status"
23 "google.golang.org/protobuf/proto"
24 )
25
26
27 var _ codes.Code
28 var _ io.Reader
29 var _ status.Status
30 var _ = runtime.String
31 var _ = utilities.NewDoubleArray
32 var _ = metadata.Join
33
34 var (
35 filter_Greeter_SayHello_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
36 )
37
38 func request_Greeter_SayHello_0(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
39 var protoReq HelloRequest
40 var metadata runtime.ServerMetadata
41
42 var (
43 val string
44 ok bool
45 err error
46 _ = err
47 )
48
49 val, ok = pathParams["name"]
50 if !ok {
51 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
52 }
53
54 protoReq.Name, err = runtime.String(val)
55 if err != nil {
56 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
57 }
58
59 if err := req.ParseForm(); err != nil {
60 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
61 }
62 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_0); err != nil {
63 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
64 }
65
66 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
67 return msg, metadata, err
68
69 }
70
71 func local_request_Greeter_SayHello_0(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
72 var protoReq HelloRequest
73 var metadata runtime.ServerMetadata
74
75 var (
76 val string
77 ok bool
78 err error
79 _ = err
80 )
81
82 val, ok = pathParams["name"]
83 if !ok {
84 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
85 }
86
87 protoReq.Name, err = runtime.String(val)
88 if err != nil {
89 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
90 }
91
92 if err := req.ParseForm(); err != nil {
93 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
94 }
95 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_0); err != nil {
96 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
97 }
98
99 msg, err := server.SayHello(ctx, &protoReq)
100 return msg, metadata, err
101
102 }
103
104 var (
105 filter_Greeter_SayHello_1 = &utilities.DoubleArray{Encoding: map[string]int{"strVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
106 )
107
108 func request_Greeter_SayHello_1(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
109 var protoReq HelloRequest
110 var metadata runtime.ServerMetadata
111
112 var (
113 val string
114 ok bool
115 err error
116 _ = err
117 )
118
119 val, ok = pathParams["strVal"]
120 if !ok {
121 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "strVal")
122 }
123
124 protoReq.StrVal, err = runtime.StringValue(val)
125 if err != nil {
126 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "strVal", err)
127 }
128
129 if err := req.ParseForm(); err != nil {
130 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
131 }
132 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_1); err != nil {
133 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
134 }
135
136 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
137 return msg, metadata, err
138
139 }
140
141 func local_request_Greeter_SayHello_1(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
142 var protoReq HelloRequest
143 var metadata runtime.ServerMetadata
144
145 var (
146 val string
147 ok bool
148 err error
149 _ = err
150 )
151
152 val, ok = pathParams["strVal"]
153 if !ok {
154 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "strVal")
155 }
156
157 protoReq.StrVal, err = runtime.StringValue(val)
158 if err != nil {
159 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "strVal", err)
160 }
161
162 if err := req.ParseForm(); err != nil {
163 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
164 }
165 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_1); err != nil {
166 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
167 }
168
169 msg, err := server.SayHello(ctx, &protoReq)
170 return msg, metadata, err
171
172 }
173
174 var (
175 filter_Greeter_SayHello_2 = &utilities.DoubleArray{Encoding: map[string]int{"floatVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
176 )
177
178 func request_Greeter_SayHello_2(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
179 var protoReq HelloRequest
180 var metadata runtime.ServerMetadata
181
182 var (
183 val string
184 ok bool
185 err error
186 _ = err
187 )
188
189 val, ok = pathParams["floatVal"]
190 if !ok {
191 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "floatVal")
192 }
193
194 protoReq.FloatVal, err = runtime.FloatValue(val)
195 if err != nil {
196 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "floatVal", err)
197 }
198
199 if err := req.ParseForm(); err != nil {
200 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
201 }
202 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_2); err != nil {
203 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
204 }
205
206 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
207 return msg, metadata, err
208
209 }
210
211 func local_request_Greeter_SayHello_2(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
212 var protoReq HelloRequest
213 var metadata runtime.ServerMetadata
214
215 var (
216 val string
217 ok bool
218 err error
219 _ = err
220 )
221
222 val, ok = pathParams["floatVal"]
223 if !ok {
224 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "floatVal")
225 }
226
227 protoReq.FloatVal, err = runtime.FloatValue(val)
228 if err != nil {
229 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "floatVal", err)
230 }
231
232 if err := req.ParseForm(); err != nil {
233 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
234 }
235 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_2); err != nil {
236 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
237 }
238
239 msg, err := server.SayHello(ctx, &protoReq)
240 return msg, metadata, err
241
242 }
243
244 var (
245 filter_Greeter_SayHello_3 = &utilities.DoubleArray{Encoding: map[string]int{"doubleVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
246 )
247
248 func request_Greeter_SayHello_3(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
249 var protoReq HelloRequest
250 var metadata runtime.ServerMetadata
251
252 var (
253 val string
254 ok bool
255 err error
256 _ = err
257 )
258
259 val, ok = pathParams["doubleVal"]
260 if !ok {
261 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "doubleVal")
262 }
263
264 protoReq.DoubleVal, err = runtime.DoubleValue(val)
265 if err != nil {
266 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "doubleVal", err)
267 }
268
269 if err := req.ParseForm(); err != nil {
270 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
271 }
272 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_3); err != nil {
273 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
274 }
275
276 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
277 return msg, metadata, err
278
279 }
280
281 func local_request_Greeter_SayHello_3(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
282 var protoReq HelloRequest
283 var metadata runtime.ServerMetadata
284
285 var (
286 val string
287 ok bool
288 err error
289 _ = err
290 )
291
292 val, ok = pathParams["doubleVal"]
293 if !ok {
294 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "doubleVal")
295 }
296
297 protoReq.DoubleVal, err = runtime.DoubleValue(val)
298 if err != nil {
299 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "doubleVal", err)
300 }
301
302 if err := req.ParseForm(); err != nil {
303 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
304 }
305 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_3); err != nil {
306 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
307 }
308
309 msg, err := server.SayHello(ctx, &protoReq)
310 return msg, metadata, err
311
312 }
313
314 var (
315 filter_Greeter_SayHello_4 = &utilities.DoubleArray{Encoding: map[string]int{"boolVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
316 )
317
318 func request_Greeter_SayHello_4(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
319 var protoReq HelloRequest
320 var metadata runtime.ServerMetadata
321
322 var (
323 val string
324 ok bool
325 err error
326 _ = err
327 )
328
329 val, ok = pathParams["boolVal"]
330 if !ok {
331 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "boolVal")
332 }
333
334 protoReq.BoolVal, err = runtime.BoolValue(val)
335 if err != nil {
336 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "boolVal", err)
337 }
338
339 if err := req.ParseForm(); err != nil {
340 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
341 }
342 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_4); err != nil {
343 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
344 }
345
346 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
347 return msg, metadata, err
348
349 }
350
351 func local_request_Greeter_SayHello_4(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
352 var protoReq HelloRequest
353 var metadata runtime.ServerMetadata
354
355 var (
356 val string
357 ok bool
358 err error
359 _ = err
360 )
361
362 val, ok = pathParams["boolVal"]
363 if !ok {
364 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "boolVal")
365 }
366
367 protoReq.BoolVal, err = runtime.BoolValue(val)
368 if err != nil {
369 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "boolVal", err)
370 }
371
372 if err := req.ParseForm(); err != nil {
373 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
374 }
375 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_4); err != nil {
376 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
377 }
378
379 msg, err := server.SayHello(ctx, &protoReq)
380 return msg, metadata, err
381
382 }
383
384 var (
385 filter_Greeter_SayHello_5 = &utilities.DoubleArray{Encoding: map[string]int{"bytesVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
386 )
387
388 func request_Greeter_SayHello_5(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
389 var protoReq HelloRequest
390 var metadata runtime.ServerMetadata
391
392 var (
393 val string
394 ok bool
395 err error
396 _ = err
397 )
398
399 val, ok = pathParams["bytesVal"]
400 if !ok {
401 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bytesVal")
402 }
403
404 protoReq.BytesVal, err = runtime.BytesValue(val)
405 if err != nil {
406 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bytesVal", err)
407 }
408
409 if err := req.ParseForm(); err != nil {
410 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
411 }
412 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_5); err != nil {
413 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
414 }
415
416 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
417 return msg, metadata, err
418
419 }
420
421 func local_request_Greeter_SayHello_5(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
422 var protoReq HelloRequest
423 var metadata runtime.ServerMetadata
424
425 var (
426 val string
427 ok bool
428 err error
429 _ = err
430 )
431
432 val, ok = pathParams["bytesVal"]
433 if !ok {
434 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bytesVal")
435 }
436
437 protoReq.BytesVal, err = runtime.BytesValue(val)
438 if err != nil {
439 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bytesVal", err)
440 }
441
442 if err := req.ParseForm(); err != nil {
443 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
444 }
445 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_5); err != nil {
446 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
447 }
448
449 msg, err := server.SayHello(ctx, &protoReq)
450 return msg, metadata, err
451
452 }
453
454 var (
455 filter_Greeter_SayHello_6 = &utilities.DoubleArray{Encoding: map[string]int{"int32Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
456 )
457
458 func request_Greeter_SayHello_6(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
459 var protoReq HelloRequest
460 var metadata runtime.ServerMetadata
461
462 var (
463 val string
464 ok bool
465 err error
466 _ = err
467 )
468
469 val, ok = pathParams["int32Val"]
470 if !ok {
471 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32Val")
472 }
473
474 protoReq.Int32Val, err = runtime.Int32Value(val)
475 if err != nil {
476 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32Val", err)
477 }
478
479 if err := req.ParseForm(); err != nil {
480 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
481 }
482 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_6); err != nil {
483 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
484 }
485
486 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
487 return msg, metadata, err
488
489 }
490
491 func local_request_Greeter_SayHello_6(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
492 var protoReq HelloRequest
493 var metadata runtime.ServerMetadata
494
495 var (
496 val string
497 ok bool
498 err error
499 _ = err
500 )
501
502 val, ok = pathParams["int32Val"]
503 if !ok {
504 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32Val")
505 }
506
507 protoReq.Int32Val, err = runtime.Int32Value(val)
508 if err != nil {
509 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32Val", err)
510 }
511
512 if err := req.ParseForm(); err != nil {
513 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
514 }
515 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_6); err != nil {
516 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
517 }
518
519 msg, err := server.SayHello(ctx, &protoReq)
520 return msg, metadata, err
521
522 }
523
524 var (
525 filter_Greeter_SayHello_7 = &utilities.DoubleArray{Encoding: map[string]int{"uint32Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
526 )
527
528 func request_Greeter_SayHello_7(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
529 var protoReq HelloRequest
530 var metadata runtime.ServerMetadata
531
532 var (
533 val string
534 ok bool
535 err error
536 _ = err
537 )
538
539 val, ok = pathParams["uint32Val"]
540 if !ok {
541 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32Val")
542 }
543
544 protoReq.Uint32Val, err = runtime.UInt32Value(val)
545 if err != nil {
546 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32Val", err)
547 }
548
549 if err := req.ParseForm(); err != nil {
550 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
551 }
552 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_7); err != nil {
553 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
554 }
555
556 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
557 return msg, metadata, err
558
559 }
560
561 func local_request_Greeter_SayHello_7(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
562 var protoReq HelloRequest
563 var metadata runtime.ServerMetadata
564
565 var (
566 val string
567 ok bool
568 err error
569 _ = err
570 )
571
572 val, ok = pathParams["uint32Val"]
573 if !ok {
574 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32Val")
575 }
576
577 protoReq.Uint32Val, err = runtime.UInt32Value(val)
578 if err != nil {
579 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32Val", err)
580 }
581
582 if err := req.ParseForm(); err != nil {
583 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
584 }
585 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_7); err != nil {
586 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
587 }
588
589 msg, err := server.SayHello(ctx, &protoReq)
590 return msg, metadata, err
591
592 }
593
594 var (
595 filter_Greeter_SayHello_8 = &utilities.DoubleArray{Encoding: map[string]int{"int64Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
596 )
597
598 func request_Greeter_SayHello_8(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
599 var protoReq HelloRequest
600 var metadata runtime.ServerMetadata
601
602 var (
603 val string
604 ok bool
605 err error
606 _ = err
607 )
608
609 val, ok = pathParams["int64Val"]
610 if !ok {
611 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64Val")
612 }
613
614 protoReq.Int64Val, err = runtime.Int64Value(val)
615 if err != nil {
616 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64Val", err)
617 }
618
619 if err := req.ParseForm(); err != nil {
620 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
621 }
622 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_8); err != nil {
623 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
624 }
625
626 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
627 return msg, metadata, err
628
629 }
630
631 func local_request_Greeter_SayHello_8(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
632 var protoReq HelloRequest
633 var metadata runtime.ServerMetadata
634
635 var (
636 val string
637 ok bool
638 err error
639 _ = err
640 )
641
642 val, ok = pathParams["int64Val"]
643 if !ok {
644 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64Val")
645 }
646
647 protoReq.Int64Val, err = runtime.Int64Value(val)
648 if err != nil {
649 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64Val", err)
650 }
651
652 if err := req.ParseForm(); err != nil {
653 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
654 }
655 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_8); err != nil {
656 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
657 }
658
659 msg, err := server.SayHello(ctx, &protoReq)
660 return msg, metadata, err
661
662 }
663
664 var (
665 filter_Greeter_SayHello_9 = &utilities.DoubleArray{Encoding: map[string]int{"uint64Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
666 )
667
668 func request_Greeter_SayHello_9(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
669 var protoReq HelloRequest
670 var metadata runtime.ServerMetadata
671
672 var (
673 val string
674 ok bool
675 err error
676 _ = err
677 )
678
679 val, ok = pathParams["uint64Val"]
680 if !ok {
681 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64Val")
682 }
683
684 protoReq.Uint64Val, err = runtime.UInt64Value(val)
685 if err != nil {
686 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64Val", err)
687 }
688
689 if err := req.ParseForm(); err != nil {
690 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
691 }
692 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_9); err != nil {
693 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
694 }
695
696 msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
697 return msg, metadata, err
698
699 }
700
701 func local_request_Greeter_SayHello_9(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
702 var protoReq HelloRequest
703 var metadata runtime.ServerMetadata
704
705 var (
706 val string
707 ok bool
708 err error
709 _ = err
710 )
711
712 val, ok = pathParams["uint64Val"]
713 if !ok {
714 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64Val")
715 }
716
717 protoReq.Uint64Val, err = runtime.UInt64Value(val)
718 if err != nil {
719 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64Val", err)
720 }
721
722 if err := req.ParseForm(); err != nil {
723 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
724 }
725 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_9); err != nil {
726 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
727 }
728
729 msg, err := server.SayHello(ctx, &protoReq)
730 return msg, metadata, err
731
732 }
733
734
735
736
737
738 func RegisterGreeterHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GreeterServer) error {
739
740 mux.Handle("GET", pattern_Greeter_SayHello_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
741 ctx, cancel := context.WithCancel(req.Context())
742 defer cancel()
743 var stream runtime.ServerTransportStream
744 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
745 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
746 var err error
747 var annotatedContext context.Context
748 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/{name}"))
749 if err != nil {
750 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
751 return
752 }
753 resp, md, err := local_request_Greeter_SayHello_0(annotatedContext, inboundMarshaler, server, req, pathParams)
754 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
755 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
756 if err != nil {
757 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
758 return
759 }
760
761 forward_Greeter_SayHello_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
762
763 })
764
765 mux.Handle("GET", pattern_Greeter_SayHello_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
766 ctx, cancel := context.WithCancel(req.Context())
767 defer cancel()
768 var stream runtime.ServerTransportStream
769 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
770 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
771 var err error
772 var annotatedContext context.Context
773 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/strval/{strVal}"))
774 if err != nil {
775 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
776 return
777 }
778 resp, md, err := local_request_Greeter_SayHello_1(annotatedContext, inboundMarshaler, server, req, pathParams)
779 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
780 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
781 if err != nil {
782 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
783 return
784 }
785
786 forward_Greeter_SayHello_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
787
788 })
789
790 mux.Handle("GET", pattern_Greeter_SayHello_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
791 ctx, cancel := context.WithCancel(req.Context())
792 defer cancel()
793 var stream runtime.ServerTransportStream
794 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
795 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
796 var err error
797 var annotatedContext context.Context
798 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/floatval/{floatVal}"))
799 if err != nil {
800 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
801 return
802 }
803 resp, md, err := local_request_Greeter_SayHello_2(annotatedContext, inboundMarshaler, server, req, pathParams)
804 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
805 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
806 if err != nil {
807 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
808 return
809 }
810
811 forward_Greeter_SayHello_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
812
813 })
814
815 mux.Handle("GET", pattern_Greeter_SayHello_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
816 ctx, cancel := context.WithCancel(req.Context())
817 defer cancel()
818 var stream runtime.ServerTransportStream
819 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
820 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
821 var err error
822 var annotatedContext context.Context
823 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/doubleval/{doubleVal}"))
824 if err != nil {
825 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
826 return
827 }
828 resp, md, err := local_request_Greeter_SayHello_3(annotatedContext, inboundMarshaler, server, req, pathParams)
829 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
830 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
831 if err != nil {
832 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
833 return
834 }
835
836 forward_Greeter_SayHello_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
837
838 })
839
840 mux.Handle("GET", pattern_Greeter_SayHello_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
841 ctx, cancel := context.WithCancel(req.Context())
842 defer cancel()
843 var stream runtime.ServerTransportStream
844 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
845 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
846 var err error
847 var annotatedContext context.Context
848 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/boolval/{boolVal}"))
849 if err != nil {
850 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
851 return
852 }
853 resp, md, err := local_request_Greeter_SayHello_4(annotatedContext, inboundMarshaler, server, req, pathParams)
854 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
855 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
856 if err != nil {
857 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
858 return
859 }
860
861 forward_Greeter_SayHello_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
862
863 })
864
865 mux.Handle("GET", pattern_Greeter_SayHello_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
866 ctx, cancel := context.WithCancel(req.Context())
867 defer cancel()
868 var stream runtime.ServerTransportStream
869 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
870 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
871 var err error
872 var annotatedContext context.Context
873 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/bytesval/{bytesVal}"))
874 if err != nil {
875 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
876 return
877 }
878 resp, md, err := local_request_Greeter_SayHello_5(annotatedContext, inboundMarshaler, server, req, pathParams)
879 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
880 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
881 if err != nil {
882 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
883 return
884 }
885
886 forward_Greeter_SayHello_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
887
888 })
889
890 mux.Handle("GET", pattern_Greeter_SayHello_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
891 ctx, cancel := context.WithCancel(req.Context())
892 defer cancel()
893 var stream runtime.ServerTransportStream
894 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
895 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
896 var err error
897 var annotatedContext context.Context
898 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int32val/{int32Val}"))
899 if err != nil {
900 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
901 return
902 }
903 resp, md, err := local_request_Greeter_SayHello_6(annotatedContext, inboundMarshaler, server, req, pathParams)
904 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
905 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
906 if err != nil {
907 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
908 return
909 }
910
911 forward_Greeter_SayHello_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
912
913 })
914
915 mux.Handle("GET", pattern_Greeter_SayHello_7, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
916 ctx, cancel := context.WithCancel(req.Context())
917 defer cancel()
918 var stream runtime.ServerTransportStream
919 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
920 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
921 var err error
922 var annotatedContext context.Context
923 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint32val/{uint32Val}"))
924 if err != nil {
925 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
926 return
927 }
928 resp, md, err := local_request_Greeter_SayHello_7(annotatedContext, inboundMarshaler, server, req, pathParams)
929 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
930 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
931 if err != nil {
932 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
933 return
934 }
935
936 forward_Greeter_SayHello_7(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
937
938 })
939
940 mux.Handle("GET", pattern_Greeter_SayHello_8, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
941 ctx, cancel := context.WithCancel(req.Context())
942 defer cancel()
943 var stream runtime.ServerTransportStream
944 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
945 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
946 var err error
947 var annotatedContext context.Context
948 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int64val/{int64Val}"))
949 if err != nil {
950 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
951 return
952 }
953 resp, md, err := local_request_Greeter_SayHello_8(annotatedContext, inboundMarshaler, server, req, pathParams)
954 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
955 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
956 if err != nil {
957 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
958 return
959 }
960
961 forward_Greeter_SayHello_8(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
962
963 })
964
965 mux.Handle("GET", pattern_Greeter_SayHello_9, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
966 ctx, cancel := context.WithCancel(req.Context())
967 defer cancel()
968 var stream runtime.ServerTransportStream
969 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
970 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
971 var err error
972 var annotatedContext context.Context
973 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint64val/{uint64Val}"))
974 if err != nil {
975 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
976 return
977 }
978 resp, md, err := local_request_Greeter_SayHello_9(annotatedContext, inboundMarshaler, server, req, pathParams)
979 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
980 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
981 if err != nil {
982 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
983 return
984 }
985
986 forward_Greeter_SayHello_9(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
987
988 })
989
990 return nil
991 }
992
993
994
995 func RegisterGreeterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
996 conn, err := grpc.DialContext(ctx, endpoint, opts...)
997 if err != nil {
998 return err
999 }
1000 defer func() {
1001 if err != nil {
1002 if cerr := conn.Close(); cerr != nil {
1003 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
1004 }
1005 return
1006 }
1007 go func() {
1008 <-ctx.Done()
1009 if cerr := conn.Close(); cerr != nil {
1010 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
1011 }
1012 }()
1013 }()
1014
1015 return RegisterGreeterHandler(ctx, mux, conn)
1016 }
1017
1018
1019
1020 func RegisterGreeterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
1021 return RegisterGreeterHandlerClient(ctx, mux, NewGreeterClient(conn))
1022 }
1023
1024
1025
1026
1027
1028
1029 func RegisterGreeterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GreeterClient) error {
1030
1031 mux.Handle("GET", pattern_Greeter_SayHello_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1032 ctx, cancel := context.WithCancel(req.Context())
1033 defer cancel()
1034 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1035 var err error
1036 var annotatedContext context.Context
1037 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/{name}"))
1038 if err != nil {
1039 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1040 return
1041 }
1042 resp, md, err := request_Greeter_SayHello_0(annotatedContext, inboundMarshaler, client, req, pathParams)
1043 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1044 if err != nil {
1045 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1046 return
1047 }
1048
1049 forward_Greeter_SayHello_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1050
1051 })
1052
1053 mux.Handle("GET", pattern_Greeter_SayHello_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1054 ctx, cancel := context.WithCancel(req.Context())
1055 defer cancel()
1056 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1057 var err error
1058 var annotatedContext context.Context
1059 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/strval/{strVal}"))
1060 if err != nil {
1061 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1062 return
1063 }
1064 resp, md, err := request_Greeter_SayHello_1(annotatedContext, inboundMarshaler, client, req, pathParams)
1065 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1066 if err != nil {
1067 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1068 return
1069 }
1070
1071 forward_Greeter_SayHello_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1072
1073 })
1074
1075 mux.Handle("GET", pattern_Greeter_SayHello_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1076 ctx, cancel := context.WithCancel(req.Context())
1077 defer cancel()
1078 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1079 var err error
1080 var annotatedContext context.Context
1081 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/floatval/{floatVal}"))
1082 if err != nil {
1083 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1084 return
1085 }
1086 resp, md, err := request_Greeter_SayHello_2(annotatedContext, inboundMarshaler, client, req, pathParams)
1087 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1088 if err != nil {
1089 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1090 return
1091 }
1092
1093 forward_Greeter_SayHello_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1094
1095 })
1096
1097 mux.Handle("GET", pattern_Greeter_SayHello_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1098 ctx, cancel := context.WithCancel(req.Context())
1099 defer cancel()
1100 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1101 var err error
1102 var annotatedContext context.Context
1103 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/doubleval/{doubleVal}"))
1104 if err != nil {
1105 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1106 return
1107 }
1108 resp, md, err := request_Greeter_SayHello_3(annotatedContext, inboundMarshaler, client, req, pathParams)
1109 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1110 if err != nil {
1111 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1112 return
1113 }
1114
1115 forward_Greeter_SayHello_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1116
1117 })
1118
1119 mux.Handle("GET", pattern_Greeter_SayHello_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1120 ctx, cancel := context.WithCancel(req.Context())
1121 defer cancel()
1122 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1123 var err error
1124 var annotatedContext context.Context
1125 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/boolval/{boolVal}"))
1126 if err != nil {
1127 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1128 return
1129 }
1130 resp, md, err := request_Greeter_SayHello_4(annotatedContext, inboundMarshaler, client, req, pathParams)
1131 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1132 if err != nil {
1133 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1134 return
1135 }
1136
1137 forward_Greeter_SayHello_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1138
1139 })
1140
1141 mux.Handle("GET", pattern_Greeter_SayHello_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1142 ctx, cancel := context.WithCancel(req.Context())
1143 defer cancel()
1144 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1145 var err error
1146 var annotatedContext context.Context
1147 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/bytesval/{bytesVal}"))
1148 if err != nil {
1149 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1150 return
1151 }
1152 resp, md, err := request_Greeter_SayHello_5(annotatedContext, inboundMarshaler, client, req, pathParams)
1153 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1154 if err != nil {
1155 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1156 return
1157 }
1158
1159 forward_Greeter_SayHello_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1160
1161 })
1162
1163 mux.Handle("GET", pattern_Greeter_SayHello_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1164 ctx, cancel := context.WithCancel(req.Context())
1165 defer cancel()
1166 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1167 var err error
1168 var annotatedContext context.Context
1169 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int32val/{int32Val}"))
1170 if err != nil {
1171 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1172 return
1173 }
1174 resp, md, err := request_Greeter_SayHello_6(annotatedContext, inboundMarshaler, client, req, pathParams)
1175 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1176 if err != nil {
1177 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1178 return
1179 }
1180
1181 forward_Greeter_SayHello_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1182
1183 })
1184
1185 mux.Handle("GET", pattern_Greeter_SayHello_7, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1186 ctx, cancel := context.WithCancel(req.Context())
1187 defer cancel()
1188 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1189 var err error
1190 var annotatedContext context.Context
1191 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint32val/{uint32Val}"))
1192 if err != nil {
1193 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1194 return
1195 }
1196 resp, md, err := request_Greeter_SayHello_7(annotatedContext, inboundMarshaler, client, req, pathParams)
1197 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1198 if err != nil {
1199 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1200 return
1201 }
1202
1203 forward_Greeter_SayHello_7(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1204
1205 })
1206
1207 mux.Handle("GET", pattern_Greeter_SayHello_8, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1208 ctx, cancel := context.WithCancel(req.Context())
1209 defer cancel()
1210 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1211 var err error
1212 var annotatedContext context.Context
1213 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int64val/{int64Val}"))
1214 if err != nil {
1215 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1216 return
1217 }
1218 resp, md, err := request_Greeter_SayHello_8(annotatedContext, inboundMarshaler, client, req, pathParams)
1219 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1220 if err != nil {
1221 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1222 return
1223 }
1224
1225 forward_Greeter_SayHello_8(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1226
1227 })
1228
1229 mux.Handle("GET", pattern_Greeter_SayHello_9, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1230 ctx, cancel := context.WithCancel(req.Context())
1231 defer cancel()
1232 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1233 var err error
1234 var annotatedContext context.Context
1235 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint64val/{uint64Val}"))
1236 if err != nil {
1237 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1238 return
1239 }
1240 resp, md, err := request_Greeter_SayHello_9(annotatedContext, inboundMarshaler, client, req, pathParams)
1241 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1242 if err != nil {
1243 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1244 return
1245 }
1246
1247 forward_Greeter_SayHello_9(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1248
1249 })
1250
1251 return nil
1252 }
1253
1254 var (
1255 pattern_Greeter_SayHello_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"say", "name"}, ""))
1256
1257 pattern_Greeter_SayHello_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "strval", "strVal"}, ""))
1258
1259 pattern_Greeter_SayHello_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "floatval", "floatVal"}, ""))
1260
1261 pattern_Greeter_SayHello_3 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "doubleval", "doubleVal"}, ""))
1262
1263 pattern_Greeter_SayHello_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "boolval", "boolVal"}, ""))
1264
1265 pattern_Greeter_SayHello_5 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "bytesval", "bytesVal"}, ""))
1266
1267 pattern_Greeter_SayHello_6 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "int32val", "int32Val"}, ""))
1268
1269 pattern_Greeter_SayHello_7 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "uint32val", "uint32Val"}, ""))
1270
1271 pattern_Greeter_SayHello_8 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "int64val", "int64Val"}, ""))
1272
1273 pattern_Greeter_SayHello_9 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "uint64val", "uint64Val"}, ""))
1274 )
1275
1276 var (
1277 forward_Greeter_SayHello_0 = runtime.ForwardResponseMessage
1278
1279 forward_Greeter_SayHello_1 = runtime.ForwardResponseMessage
1280
1281 forward_Greeter_SayHello_2 = runtime.ForwardResponseMessage
1282
1283 forward_Greeter_SayHello_3 = runtime.ForwardResponseMessage
1284
1285 forward_Greeter_SayHello_4 = runtime.ForwardResponseMessage
1286
1287 forward_Greeter_SayHello_5 = runtime.ForwardResponseMessage
1288
1289 forward_Greeter_SayHello_6 = runtime.ForwardResponseMessage
1290
1291 forward_Greeter_SayHello_7 = runtime.ForwardResponseMessage
1292
1293 forward_Greeter_SayHello_8 = runtime.ForwardResponseMessage
1294
1295 forward_Greeter_SayHello_9 = runtime.ForwardResponseMessage
1296 )
1297
View as plain text