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