1
2
3
4
9 package examplepb
10
11 import (
12 "context"
13 "io"
14 "net/http"
15
16 "github.com/grpc-ecosystem/grpc-gateway/v2/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 func request_FlowCombination_RpcEmptyRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
35 var protoReq EmptyProto
36 var metadata runtime.ServerMetadata
37
38 msg, err := client.RpcEmptyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
39 return msg, metadata, err
40
41 }
42
43 func local_request_FlowCombination_RpcEmptyRpc_0(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
44 var protoReq EmptyProto
45 var metadata runtime.ServerMetadata
46
47 msg, err := server.RpcEmptyRpc(ctx, &protoReq)
48 return msg, metadata, err
49
50 }
51
52 func request_FlowCombination_RpcEmptyStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcEmptyStreamClient, runtime.ServerMetadata, error) {
53 var protoReq EmptyProto
54 var metadata runtime.ServerMetadata
55
56 stream, err := client.RpcEmptyStream(ctx, &protoReq)
57 if err != nil {
58 return nil, metadata, err
59 }
60 header, err := stream.Header()
61 if err != nil {
62 return nil, metadata, err
63 }
64 metadata.HeaderMD = header
65 return stream, metadata, nil
66
67 }
68
69 func request_FlowCombination_StreamEmptyRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
70 var metadata runtime.ServerMetadata
71 stream, err := client.StreamEmptyRpc(ctx)
72 if err != nil {
73 grpclog.Infof("Failed to start streaming: %v", err)
74 return nil, metadata, err
75 }
76 dec := marshaler.NewDecoder(req.Body)
77 for {
78 var protoReq EmptyProto
79 err = dec.Decode(&protoReq)
80 if err == io.EOF {
81 break
82 }
83 if err != nil {
84 grpclog.Infof("Failed to decode request: %v", err)
85 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
86 }
87 if err = stream.Send(&protoReq); err != nil {
88 if err == io.EOF {
89 break
90 }
91 grpclog.Infof("Failed to send request: %v", err)
92 return nil, metadata, err
93 }
94 }
95
96 if err := stream.CloseSend(); err != nil {
97 grpclog.Infof("Failed to terminate client stream: %v", err)
98 return nil, metadata, err
99 }
100 header, err := stream.Header()
101 if err != nil {
102 grpclog.Infof("Failed to get header from client: %v", err)
103 return nil, metadata, err
104 }
105 metadata.HeaderMD = header
106
107 msg, err := stream.CloseAndRecv()
108 metadata.TrailerMD = stream.Trailer()
109 return msg, metadata, err
110
111 }
112
113 func request_FlowCombination_StreamEmptyStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_StreamEmptyStreamClient, runtime.ServerMetadata, error) {
114 var metadata runtime.ServerMetadata
115 stream, err := client.StreamEmptyStream(ctx)
116 if err != nil {
117 grpclog.Infof("Failed to start streaming: %v", err)
118 return nil, metadata, err
119 }
120 dec := marshaler.NewDecoder(req.Body)
121 handleSend := func() error {
122 var protoReq EmptyProto
123 err := dec.Decode(&protoReq)
124 if err == io.EOF {
125 return err
126 }
127 if err != nil {
128 grpclog.Infof("Failed to decode request: %v", err)
129 return err
130 }
131 if err := stream.Send(&protoReq); err != nil {
132 grpclog.Infof("Failed to send request: %v", err)
133 return err
134 }
135 return nil
136 }
137 go func() {
138 for {
139 if err := handleSend(); err != nil {
140 break
141 }
142 }
143 if err := stream.CloseSend(); err != nil {
144 grpclog.Infof("Failed to terminate client stream: %v", err)
145 }
146 }()
147 header, err := stream.Header()
148 if err != nil {
149 grpclog.Infof("Failed to get header from client: %v", err)
150 return nil, metadata, err
151 }
152 metadata.HeaderMD = header
153 return stream, metadata, nil
154 }
155
156 func request_FlowCombination_RpcBodyRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
157 var protoReq NonEmptyProto
158 var metadata runtime.ServerMetadata
159
160 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
161 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
162 }
163
164 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
165 return msg, metadata, err
166
167 }
168
169 func local_request_FlowCombination_RpcBodyRpc_0(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
170 var protoReq NonEmptyProto
171 var metadata runtime.ServerMetadata
172
173 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
174 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
175 }
176
177 msg, err := server.RpcBodyRpc(ctx, &protoReq)
178 return msg, metadata, err
179
180 }
181
182 func request_FlowCombination_RpcBodyRpc_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
183 var protoReq NonEmptyProto
184 var metadata runtime.ServerMetadata
185
186 var (
187 val string
188 ok bool
189 err error
190 _ = err
191 )
192
193 val, ok = pathParams["a"]
194 if !ok {
195 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
196 }
197
198 protoReq.A, err = runtime.String(val)
199 if err != nil {
200 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
201 }
202
203 val, ok = pathParams["b"]
204 if !ok {
205 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
206 }
207
208 protoReq.B, err = runtime.String(val)
209 if err != nil {
210 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
211 }
212
213 val, ok = pathParams["c"]
214 if !ok {
215 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "c")
216 }
217
218 protoReq.C, err = runtime.String(val)
219 if err != nil {
220 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "c", err)
221 }
222
223 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
224 return msg, metadata, err
225
226 }
227
228 func local_request_FlowCombination_RpcBodyRpc_1(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
229 var protoReq NonEmptyProto
230 var metadata runtime.ServerMetadata
231
232 var (
233 val string
234 ok bool
235 err error
236 _ = err
237 )
238
239 val, ok = pathParams["a"]
240 if !ok {
241 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
242 }
243
244 protoReq.A, err = runtime.String(val)
245 if err != nil {
246 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
247 }
248
249 val, ok = pathParams["b"]
250 if !ok {
251 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
252 }
253
254 protoReq.B, err = runtime.String(val)
255 if err != nil {
256 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
257 }
258
259 val, ok = pathParams["c"]
260 if !ok {
261 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "c")
262 }
263
264 protoReq.C, err = runtime.String(val)
265 if err != nil {
266 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "c", err)
267 }
268
269 msg, err := server.RpcBodyRpc(ctx, &protoReq)
270 return msg, metadata, err
271
272 }
273
274 var (
275 filter_FlowCombination_RpcBodyRpc_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
276 )
277
278 func request_FlowCombination_RpcBodyRpc_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
279 var protoReq NonEmptyProto
280 var metadata runtime.ServerMetadata
281
282 if err := req.ParseForm(); err != nil {
283 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
284 }
285 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_2); err != nil {
286 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
287 }
288
289 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
290 return msg, metadata, err
291
292 }
293
294 func local_request_FlowCombination_RpcBodyRpc_2(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
295 var protoReq NonEmptyProto
296 var metadata runtime.ServerMetadata
297
298 if err := req.ParseForm(); err != nil {
299 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
300 }
301 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_2); err != nil {
302 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
303 }
304
305 msg, err := server.RpcBodyRpc(ctx, &protoReq)
306 return msg, metadata, err
307
308 }
309
310 func request_FlowCombination_RpcBodyRpc_3(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
311 var protoReq NonEmptyProto
312 var metadata runtime.ServerMetadata
313
314 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
315 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
316 }
317
318 var (
319 val string
320 ok bool
321 err error
322 _ = err
323 )
324
325 val, ok = pathParams["a"]
326 if !ok {
327 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
328 }
329
330 protoReq.A, err = runtime.String(val)
331 if err != nil {
332 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
333 }
334
335 val, ok = pathParams["b"]
336 if !ok {
337 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
338 }
339
340 protoReq.B, err = runtime.String(val)
341 if err != nil {
342 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
343 }
344
345 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
346 return msg, metadata, err
347
348 }
349
350 func local_request_FlowCombination_RpcBodyRpc_3(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
351 var protoReq NonEmptyProto
352 var metadata runtime.ServerMetadata
353
354 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
355 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
356 }
357
358 var (
359 val string
360 ok bool
361 err error
362 _ = err
363 )
364
365 val, ok = pathParams["a"]
366 if !ok {
367 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
368 }
369
370 protoReq.A, err = runtime.String(val)
371 if err != nil {
372 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
373 }
374
375 val, ok = pathParams["b"]
376 if !ok {
377 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
378 }
379
380 protoReq.B, err = runtime.String(val)
381 if err != nil {
382 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
383 }
384
385 msg, err := server.RpcBodyRpc(ctx, &protoReq)
386 return msg, metadata, err
387
388 }
389
390 var (
391 filter_FlowCombination_RpcBodyRpc_4 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
392 )
393
394 func request_FlowCombination_RpcBodyRpc_4(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
395 var protoReq NonEmptyProto
396 var metadata runtime.ServerMetadata
397
398 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
399 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
400 }
401
402 if err := req.ParseForm(); err != nil {
403 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
404 }
405 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_4); err != nil {
406 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
407 }
408
409 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
410 return msg, metadata, err
411
412 }
413
414 func local_request_FlowCombination_RpcBodyRpc_4(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
415 var protoReq NonEmptyProto
416 var metadata runtime.ServerMetadata
417
418 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
419 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", 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_FlowCombination_RpcBodyRpc_4); err != nil {
426 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
427 }
428
429 msg, err := server.RpcBodyRpc(ctx, &protoReq)
430 return msg, metadata, err
431
432 }
433
434 var (
435 filter_FlowCombination_RpcBodyRpc_5 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0, "a": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
436 )
437
438 func request_FlowCombination_RpcBodyRpc_5(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
439 var protoReq NonEmptyProto
440 var metadata runtime.ServerMetadata
441
442 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
443 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
444 }
445
446 var (
447 val string
448 ok bool
449 err error
450 _ = err
451 )
452
453 val, ok = pathParams["a"]
454 if !ok {
455 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
456 }
457
458 protoReq.A, err = runtime.String(val)
459 if err != nil {
460 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
461 }
462
463 if err := req.ParseForm(); err != nil {
464 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
465 }
466 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_5); err != nil {
467 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
468 }
469
470 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
471 return msg, metadata, err
472
473 }
474
475 func local_request_FlowCombination_RpcBodyRpc_5(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
476 var protoReq NonEmptyProto
477 var metadata runtime.ServerMetadata
478
479 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
480 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
481 }
482
483 var (
484 val string
485 ok bool
486 err error
487 _ = err
488 )
489
490 val, ok = pathParams["a"]
491 if !ok {
492 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
493 }
494
495 protoReq.A, err = runtime.String(val)
496 if err != nil {
497 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
498 }
499
500 if err := req.ParseForm(); err != nil {
501 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
502 }
503 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_5); err != nil {
504 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
505 }
506
507 msg, err := server.RpcBodyRpc(ctx, &protoReq)
508 return msg, metadata, err
509
510 }
511
512 var (
513 filter_FlowCombination_RpcBodyRpc_6 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
514 )
515
516 func request_FlowCombination_RpcBodyRpc_6(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
517 var protoReq NonEmptyProto
518 var metadata runtime.ServerMetadata
519
520 var (
521 val string
522 ok bool
523 err error
524 _ = err
525 )
526
527 val, ok = pathParams["a"]
528 if !ok {
529 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
530 }
531
532 protoReq.A, err = runtime.String(val)
533 if err != nil {
534 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
535 }
536
537 if err := req.ParseForm(); err != nil {
538 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
539 }
540 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_6); err != nil {
541 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
542 }
543
544 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
545 return msg, metadata, err
546
547 }
548
549 func local_request_FlowCombination_RpcBodyRpc_6(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
550 var protoReq NonEmptyProto
551 var metadata runtime.ServerMetadata
552
553 var (
554 val string
555 ok bool
556 err error
557 _ = err
558 )
559
560 val, ok = pathParams["a"]
561 if !ok {
562 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
563 }
564
565 protoReq.A, err = runtime.String(val)
566 if err != nil {
567 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
568 }
569
570 if err := req.ParseForm(); err != nil {
571 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
572 }
573 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyRpc_6); err != nil {
574 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
575 }
576
577 msg, err := server.RpcBodyRpc(ctx, &protoReq)
578 return msg, metadata, err
579
580 }
581
582 var (
583 filter_FlowCombination_RpcPathSingleNestedRpc_0 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0, "str": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
584 )
585
586 func request_FlowCombination_RpcPathSingleNestedRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
587 var protoReq SingleNestedProto
588 var metadata runtime.ServerMetadata
589
590 var (
591 val string
592 ok bool
593 err error
594 _ = err
595 )
596
597 val, ok = pathParams["a.str"]
598 if !ok {
599 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
600 }
601
602 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
603 if err != nil {
604 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
605 }
606
607 if err := req.ParseForm(); err != nil {
608 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
609 }
610 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathSingleNestedRpc_0); err != nil {
611 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
612 }
613
614 msg, err := client.RpcPathSingleNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
615 return msg, metadata, err
616
617 }
618
619 func local_request_FlowCombination_RpcPathSingleNestedRpc_0(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
620 var protoReq SingleNestedProto
621 var metadata runtime.ServerMetadata
622
623 var (
624 val string
625 ok bool
626 err error
627 _ = err
628 )
629
630 val, ok = pathParams["a.str"]
631 if !ok {
632 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
633 }
634
635 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
636 if err != nil {
637 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
638 }
639
640 if err := req.ParseForm(); err != nil {
641 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
642 }
643 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathSingleNestedRpc_0); err != nil {
644 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
645 }
646
647 msg, err := server.RpcPathSingleNestedRpc(ctx, &protoReq)
648 return msg, metadata, err
649
650 }
651
652 var (
653 filter_FlowCombination_RpcPathNestedRpc_0 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0, "a": 1, "str": 2, "b": 3}, Base: []int{1, 1, 1, 2, 3, 0, 0, 0}, Check: []int{0, 1, 1, 3, 1, 2, 4, 5}}
654 )
655
656 func request_FlowCombination_RpcPathNestedRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
657 var protoReq NestedProto
658 var metadata runtime.ServerMetadata
659
660 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
661 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
662 }
663
664 var (
665 val string
666 ok bool
667 err error
668 _ = err
669 )
670
671 val, ok = pathParams["a.str"]
672 if !ok {
673 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
674 }
675
676 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
677 if err != nil {
678 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
679 }
680
681 val, ok = pathParams["b"]
682 if !ok {
683 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
684 }
685
686 protoReq.B, err = runtime.String(val)
687 if err != nil {
688 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
689 }
690
691 if err := req.ParseForm(); err != nil {
692 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
693 }
694 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedRpc_0); err != nil {
695 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
696 }
697
698 msg, err := client.RpcPathNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
699 return msg, metadata, err
700
701 }
702
703 func local_request_FlowCombination_RpcPathNestedRpc_0(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
704 var protoReq NestedProto
705 var metadata runtime.ServerMetadata
706
707 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
708 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
709 }
710
711 var (
712 val string
713 ok bool
714 err error
715 _ = err
716 )
717
718 val, ok = pathParams["a.str"]
719 if !ok {
720 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
721 }
722
723 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
724 if err != nil {
725 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
726 }
727
728 val, ok = pathParams["b"]
729 if !ok {
730 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
731 }
732
733 protoReq.B, err = runtime.String(val)
734 if err != nil {
735 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
736 }
737
738 if err := req.ParseForm(); err != nil {
739 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
740 }
741 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedRpc_0); err != nil {
742 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
743 }
744
745 msg, err := server.RpcPathNestedRpc(ctx, &protoReq)
746 return msg, metadata, err
747
748 }
749
750 var (
751 filter_FlowCombination_RpcPathNestedRpc_1 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0, "str": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
752 )
753
754 func request_FlowCombination_RpcPathNestedRpc_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
755 var protoReq NestedProto
756 var metadata runtime.ServerMetadata
757
758 var (
759 val string
760 ok bool
761 err error
762 _ = err
763 )
764
765 val, ok = pathParams["a.str"]
766 if !ok {
767 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
768 }
769
770 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
771 if err != nil {
772 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
773 }
774
775 if err := req.ParseForm(); err != nil {
776 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
777 }
778 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedRpc_1); err != nil {
779 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
780 }
781
782 msg, err := client.RpcPathNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
783 return msg, metadata, err
784
785 }
786
787 func local_request_FlowCombination_RpcPathNestedRpc_1(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
788 var protoReq NestedProto
789 var metadata runtime.ServerMetadata
790
791 var (
792 val string
793 ok bool
794 err error
795 _ = err
796 )
797
798 val, ok = pathParams["a.str"]
799 if !ok {
800 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
801 }
802
803 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
804 if err != nil {
805 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
806 }
807
808 if err := req.ParseForm(); err != nil {
809 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
810 }
811 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedRpc_1); err != nil {
812 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
813 }
814
815 msg, err := server.RpcPathNestedRpc(ctx, &protoReq)
816 return msg, metadata, err
817
818 }
819
820 var (
821 filter_FlowCombination_RpcPathNestedRpc_2 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0, "a": 1, "str": 2}, Base: []int{1, 1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 3, 2, 4}}
822 )
823
824 func request_FlowCombination_RpcPathNestedRpc_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
825 var protoReq NestedProto
826 var metadata runtime.ServerMetadata
827
828 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
829 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
830 }
831
832 var (
833 val string
834 ok bool
835 err error
836 _ = err
837 )
838
839 val, ok = pathParams["a.str"]
840 if !ok {
841 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
842 }
843
844 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
845 if err != nil {
846 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
847 }
848
849 if err := req.ParseForm(); err != nil {
850 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
851 }
852 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedRpc_2); err != nil {
853 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
854 }
855
856 msg, err := client.RpcPathNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
857 return msg, metadata, err
858
859 }
860
861 func local_request_FlowCombination_RpcPathNestedRpc_2(ctx context.Context, marshaler runtime.Marshaler, server FlowCombinationServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
862 var protoReq NestedProto
863 var metadata runtime.ServerMetadata
864
865 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
866 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
867 }
868
869 var (
870 val string
871 ok bool
872 err error
873 _ = err
874 )
875
876 val, ok = pathParams["a.str"]
877 if !ok {
878 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
879 }
880
881 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
882 if err != nil {
883 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
884 }
885
886 if err := req.ParseForm(); err != nil {
887 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
888 }
889 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedRpc_2); err != nil {
890 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
891 }
892
893 msg, err := server.RpcPathNestedRpc(ctx, &protoReq)
894 return msg, metadata, err
895
896 }
897
898 func request_FlowCombination_RpcBodyStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
899 var protoReq NonEmptyProto
900 var metadata runtime.ServerMetadata
901
902 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
903 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
904 }
905
906 stream, err := client.RpcBodyStream(ctx, &protoReq)
907 if err != nil {
908 return nil, metadata, err
909 }
910 header, err := stream.Header()
911 if err != nil {
912 return nil, metadata, err
913 }
914 metadata.HeaderMD = header
915 return stream, metadata, nil
916
917 }
918
919 func request_FlowCombination_RpcBodyStream_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
920 var protoReq NonEmptyProto
921 var metadata runtime.ServerMetadata
922
923 var (
924 val string
925 ok bool
926 err error
927 _ = err
928 )
929
930 val, ok = pathParams["a"]
931 if !ok {
932 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
933 }
934
935 protoReq.A, err = runtime.String(val)
936 if err != nil {
937 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
938 }
939
940 val, ok = pathParams["b"]
941 if !ok {
942 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
943 }
944
945 protoReq.B, err = runtime.String(val)
946 if err != nil {
947 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
948 }
949
950 val, ok = pathParams["c"]
951 if !ok {
952 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "c")
953 }
954
955 protoReq.C, err = runtime.String(val)
956 if err != nil {
957 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "c", err)
958 }
959
960 stream, err := client.RpcBodyStream(ctx, &protoReq)
961 if err != nil {
962 return nil, metadata, err
963 }
964 header, err := stream.Header()
965 if err != nil {
966 return nil, metadata, err
967 }
968 metadata.HeaderMD = header
969 return stream, metadata, nil
970
971 }
972
973 var (
974 filter_FlowCombination_RpcBodyStream_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
975 )
976
977 func request_FlowCombination_RpcBodyStream_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
978 var protoReq NonEmptyProto
979 var metadata runtime.ServerMetadata
980
981 if err := req.ParseForm(); err != nil {
982 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
983 }
984 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyStream_2); err != nil {
985 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
986 }
987
988 stream, err := client.RpcBodyStream(ctx, &protoReq)
989 if err != nil {
990 return nil, metadata, err
991 }
992 header, err := stream.Header()
993 if err != nil {
994 return nil, metadata, err
995 }
996 metadata.HeaderMD = header
997 return stream, metadata, nil
998
999 }
1000
1001 func request_FlowCombination_RpcBodyStream_3(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
1002 var protoReq NonEmptyProto
1003 var metadata runtime.ServerMetadata
1004
1005 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
1006 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1007 }
1008
1009 var (
1010 val string
1011 ok bool
1012 err error
1013 _ = err
1014 )
1015
1016 val, ok = pathParams["a"]
1017 if !ok {
1018 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
1019 }
1020
1021 protoReq.A, err = runtime.String(val)
1022 if err != nil {
1023 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
1024 }
1025
1026 val, ok = pathParams["b"]
1027 if !ok {
1028 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
1029 }
1030
1031 protoReq.B, err = runtime.String(val)
1032 if err != nil {
1033 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
1034 }
1035
1036 stream, err := client.RpcBodyStream(ctx, &protoReq)
1037 if err != nil {
1038 return nil, metadata, err
1039 }
1040 header, err := stream.Header()
1041 if err != nil {
1042 return nil, metadata, err
1043 }
1044 metadata.HeaderMD = header
1045 return stream, metadata, nil
1046
1047 }
1048
1049 var (
1050 filter_FlowCombination_RpcBodyStream_4 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
1051 )
1052
1053 func request_FlowCombination_RpcBodyStream_4(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
1054 var protoReq NonEmptyProto
1055 var metadata runtime.ServerMetadata
1056
1057 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
1058 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1059 }
1060
1061 if err := req.ParseForm(); err != nil {
1062 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1063 }
1064 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyStream_4); err != nil {
1065 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1066 }
1067
1068 stream, err := client.RpcBodyStream(ctx, &protoReq)
1069 if err != nil {
1070 return nil, metadata, err
1071 }
1072 header, err := stream.Header()
1073 if err != nil {
1074 return nil, metadata, err
1075 }
1076 metadata.HeaderMD = header
1077 return stream, metadata, nil
1078
1079 }
1080
1081 var (
1082 filter_FlowCombination_RpcBodyStream_5 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0, "a": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
1083 )
1084
1085 func request_FlowCombination_RpcBodyStream_5(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
1086 var protoReq NonEmptyProto
1087 var metadata runtime.ServerMetadata
1088
1089 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
1090 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1091 }
1092
1093 var (
1094 val string
1095 ok bool
1096 err error
1097 _ = err
1098 )
1099
1100 val, ok = pathParams["a"]
1101 if !ok {
1102 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
1103 }
1104
1105 protoReq.A, err = runtime.String(val)
1106 if err != nil {
1107 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
1108 }
1109
1110 if err := req.ParseForm(); err != nil {
1111 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1112 }
1113 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyStream_5); err != nil {
1114 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1115 }
1116
1117 stream, err := client.RpcBodyStream(ctx, &protoReq)
1118 if err != nil {
1119 return nil, metadata, err
1120 }
1121 header, err := stream.Header()
1122 if err != nil {
1123 return nil, metadata, err
1124 }
1125 metadata.HeaderMD = header
1126 return stream, metadata, nil
1127
1128 }
1129
1130 var (
1131 filter_FlowCombination_RpcBodyStream_6 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
1132 )
1133
1134 func request_FlowCombination_RpcBodyStream_6(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) {
1135 var protoReq NonEmptyProto
1136 var metadata runtime.ServerMetadata
1137
1138 var (
1139 val string
1140 ok bool
1141 err error
1142 _ = err
1143 )
1144
1145 val, ok = pathParams["a"]
1146 if !ok {
1147 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a")
1148 }
1149
1150 protoReq.A, err = runtime.String(val)
1151 if err != nil {
1152 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a", err)
1153 }
1154
1155 if err := req.ParseForm(); err != nil {
1156 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1157 }
1158 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcBodyStream_6); err != nil {
1159 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1160 }
1161
1162 stream, err := client.RpcBodyStream(ctx, &protoReq)
1163 if err != nil {
1164 return nil, metadata, err
1165 }
1166 header, err := stream.Header()
1167 if err != nil {
1168 return nil, metadata, err
1169 }
1170 metadata.HeaderMD = header
1171 return stream, metadata, nil
1172
1173 }
1174
1175 var (
1176 filter_FlowCombination_RpcPathSingleNestedStream_0 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0, "str": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
1177 )
1178
1179 func request_FlowCombination_RpcPathSingleNestedStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathSingleNestedStreamClient, runtime.ServerMetadata, error) {
1180 var protoReq SingleNestedProto
1181 var metadata runtime.ServerMetadata
1182
1183 var (
1184 val string
1185 ok bool
1186 err error
1187 _ = err
1188 )
1189
1190 val, ok = pathParams["a.str"]
1191 if !ok {
1192 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
1193 }
1194
1195 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
1196 if err != nil {
1197 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
1198 }
1199
1200 if err := req.ParseForm(); err != nil {
1201 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1202 }
1203 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathSingleNestedStream_0); err != nil {
1204 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1205 }
1206
1207 stream, err := client.RpcPathSingleNestedStream(ctx, &protoReq)
1208 if err != nil {
1209 return nil, metadata, err
1210 }
1211 header, err := stream.Header()
1212 if err != nil {
1213 return nil, metadata, err
1214 }
1215 metadata.HeaderMD = header
1216 return stream, metadata, nil
1217
1218 }
1219
1220 var (
1221 filter_FlowCombination_RpcPathNestedStream_0 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0, "a": 1, "str": 2, "b": 3}, Base: []int{1, 1, 1, 2, 3, 0, 0, 0}, Check: []int{0, 1, 1, 3, 1, 2, 4, 5}}
1222 )
1223
1224 func request_FlowCombination_RpcPathNestedStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathNestedStreamClient, runtime.ServerMetadata, error) {
1225 var protoReq NestedProto
1226 var metadata runtime.ServerMetadata
1227
1228 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
1229 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1230 }
1231
1232 var (
1233 val string
1234 ok bool
1235 err error
1236 _ = err
1237 )
1238
1239 val, ok = pathParams["a.str"]
1240 if !ok {
1241 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
1242 }
1243
1244 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
1245 if err != nil {
1246 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
1247 }
1248
1249 val, ok = pathParams["b"]
1250 if !ok {
1251 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "b")
1252 }
1253
1254 protoReq.B, err = runtime.String(val)
1255 if err != nil {
1256 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "b", err)
1257 }
1258
1259 if err := req.ParseForm(); err != nil {
1260 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1261 }
1262 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedStream_0); err != nil {
1263 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1264 }
1265
1266 stream, err := client.RpcPathNestedStream(ctx, &protoReq)
1267 if err != nil {
1268 return nil, metadata, err
1269 }
1270 header, err := stream.Header()
1271 if err != nil {
1272 return nil, metadata, err
1273 }
1274 metadata.HeaderMD = header
1275 return stream, metadata, nil
1276
1277 }
1278
1279 var (
1280 filter_FlowCombination_RpcPathNestedStream_1 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0, "str": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
1281 )
1282
1283 func request_FlowCombination_RpcPathNestedStream_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathNestedStreamClient, runtime.ServerMetadata, error) {
1284 var protoReq NestedProto
1285 var metadata runtime.ServerMetadata
1286
1287 var (
1288 val string
1289 ok bool
1290 err error
1291 _ = err
1292 )
1293
1294 val, ok = pathParams["a.str"]
1295 if !ok {
1296 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
1297 }
1298
1299 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
1300 if err != nil {
1301 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
1302 }
1303
1304 if err := req.ParseForm(); err != nil {
1305 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1306 }
1307 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedStream_1); err != nil {
1308 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1309 }
1310
1311 stream, err := client.RpcPathNestedStream(ctx, &protoReq)
1312 if err != nil {
1313 return nil, metadata, err
1314 }
1315 header, err := stream.Header()
1316 if err != nil {
1317 return nil, metadata, err
1318 }
1319 metadata.HeaderMD = header
1320 return stream, metadata, nil
1321
1322 }
1323
1324 var (
1325 filter_FlowCombination_RpcPathNestedStream_2 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0, "a": 1, "str": 2}, Base: []int{1, 1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 3, 2, 4}}
1326 )
1327
1328 func request_FlowCombination_RpcPathNestedStream_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathNestedStreamClient, runtime.ServerMetadata, error) {
1329 var protoReq NestedProto
1330 var metadata runtime.ServerMetadata
1331
1332 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil && err != io.EOF {
1333 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1334 }
1335
1336 var (
1337 val string
1338 ok bool
1339 err error
1340 _ = err
1341 )
1342
1343 val, ok = pathParams["a.str"]
1344 if !ok {
1345 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str")
1346 }
1347
1348 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val)
1349 if err != nil {
1350 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "a.str", err)
1351 }
1352
1353 if err := req.ParseForm(); err != nil {
1354 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1355 }
1356 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FlowCombination_RpcPathNestedStream_2); err != nil {
1357 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
1358 }
1359
1360 stream, err := client.RpcPathNestedStream(ctx, &protoReq)
1361 if err != nil {
1362 return nil, metadata, err
1363 }
1364 header, err := stream.Header()
1365 if err != nil {
1366 return nil, metadata, err
1367 }
1368 metadata.HeaderMD = header
1369 return stream, metadata, nil
1370
1371 }
1372
1373
1374
1375
1376
1377 func RegisterFlowCombinationHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FlowCombinationServer) error {
1378
1379 mux.Handle("POST", pattern_FlowCombination_RpcEmptyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1380 ctx, cancel := context.WithCancel(req.Context())
1381 defer cancel()
1382 var stream runtime.ServerTransportStream
1383 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1384 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1385 var err error
1386 var annotatedContext context.Context
1387 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyRpc", runtime.WithHTTPPathPattern("/rpc/empty/rpc"))
1388 if err != nil {
1389 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1390 return
1391 }
1392 resp, md, err := local_request_FlowCombination_RpcEmptyRpc_0(annotatedContext, inboundMarshaler, server, req, pathParams)
1393 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1394 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1395 if err != nil {
1396 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1397 return
1398 }
1399
1400 forward_FlowCombination_RpcEmptyRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1401
1402 })
1403
1404 mux.Handle("POST", pattern_FlowCombination_RpcEmptyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1405 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1406 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1407 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1408 return
1409 })
1410
1411 mux.Handle("POST", pattern_FlowCombination_StreamEmptyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1412 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1413 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1414 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1415 return
1416 })
1417
1418 mux.Handle("POST", pattern_FlowCombination_StreamEmptyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1419 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1420 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1421 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1422 return
1423 })
1424
1425 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1426 ctx, cancel := context.WithCancel(req.Context())
1427 defer cancel()
1428 var stream runtime.ServerTransportStream
1429 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1430 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1431 var err error
1432 var annotatedContext context.Context
1433 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/rpc"))
1434 if err != nil {
1435 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1436 return
1437 }
1438 resp, md, err := local_request_FlowCombination_RpcBodyRpc_0(annotatedContext, inboundMarshaler, server, req, pathParams)
1439 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1440 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1441 if err != nil {
1442 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1443 return
1444 }
1445
1446 forward_FlowCombination_RpcBodyRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1447
1448 })
1449
1450 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1451 ctx, cancel := context.WithCancel(req.Context())
1452 defer cancel()
1453 var stream runtime.ServerTransportStream
1454 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1455 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1456 var err error
1457 var annotatedContext context.Context
1458 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/path/{a}/{b}/{c}/rpc"))
1459 if err != nil {
1460 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1461 return
1462 }
1463 resp, md, err := local_request_FlowCombination_RpcBodyRpc_1(annotatedContext, inboundMarshaler, server, req, pathParams)
1464 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1465 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1466 if err != nil {
1467 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1468 return
1469 }
1470
1471 forward_FlowCombination_RpcBodyRpc_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1472
1473 })
1474
1475 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1476 ctx, cancel := context.WithCancel(req.Context())
1477 defer cancel()
1478 var stream runtime.ServerTransportStream
1479 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1480 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1481 var err error
1482 var annotatedContext context.Context
1483 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/query/rpc"))
1484 if err != nil {
1485 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1486 return
1487 }
1488 resp, md, err := local_request_FlowCombination_RpcBodyRpc_2(annotatedContext, inboundMarshaler, server, req, pathParams)
1489 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1490 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1491 if err != nil {
1492 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1493 return
1494 }
1495
1496 forward_FlowCombination_RpcBodyRpc_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1497
1498 })
1499
1500 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1501 ctx, cancel := context.WithCancel(req.Context())
1502 defer cancel()
1503 var stream runtime.ServerTransportStream
1504 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1505 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1506 var err error
1507 var annotatedContext context.Context
1508 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/path/{a}/{b}/rpc"))
1509 if err != nil {
1510 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1511 return
1512 }
1513 resp, md, err := local_request_FlowCombination_RpcBodyRpc_3(annotatedContext, inboundMarshaler, server, req, pathParams)
1514 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1515 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1516 if err != nil {
1517 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1518 return
1519 }
1520
1521 forward_FlowCombination_RpcBodyRpc_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1522
1523 })
1524
1525 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1526 ctx, cancel := context.WithCancel(req.Context())
1527 defer cancel()
1528 var stream runtime.ServerTransportStream
1529 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1530 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1531 var err error
1532 var annotatedContext context.Context
1533 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/query/rpc"))
1534 if err != nil {
1535 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1536 return
1537 }
1538 resp, md, err := local_request_FlowCombination_RpcBodyRpc_4(annotatedContext, inboundMarshaler, server, req, pathParams)
1539 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1540 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1541 if err != nil {
1542 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1543 return
1544 }
1545
1546 forward_FlowCombination_RpcBodyRpc_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1547
1548 })
1549
1550 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1551 ctx, cancel := context.WithCancel(req.Context())
1552 defer cancel()
1553 var stream runtime.ServerTransportStream
1554 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1555 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1556 var err error
1557 var annotatedContext context.Context
1558 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/path/{a}/query/rpc"))
1559 if err != nil {
1560 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1561 return
1562 }
1563 resp, md, err := local_request_FlowCombination_RpcBodyRpc_5(annotatedContext, inboundMarshaler, server, req, pathParams)
1564 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1565 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1566 if err != nil {
1567 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1568 return
1569 }
1570
1571 forward_FlowCombination_RpcBodyRpc_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1572
1573 })
1574
1575 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1576 ctx, cancel := context.WithCancel(req.Context())
1577 defer cancel()
1578 var stream runtime.ServerTransportStream
1579 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1580 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1581 var err error
1582 var annotatedContext context.Context
1583 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/path/{a}/query/rpc"))
1584 if err != nil {
1585 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1586 return
1587 }
1588 resp, md, err := local_request_FlowCombination_RpcBodyRpc_6(annotatedContext, inboundMarshaler, server, req, pathParams)
1589 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1590 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1591 if err != nil {
1592 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1593 return
1594 }
1595
1596 forward_FlowCombination_RpcBodyRpc_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1597
1598 })
1599
1600 mux.Handle("POST", pattern_FlowCombination_RpcPathSingleNestedRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1601 ctx, cancel := context.WithCancel(req.Context())
1602 defer cancel()
1603 var stream runtime.ServerTransportStream
1604 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1605 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1606 var err error
1607 var annotatedContext context.Context
1608 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested/{a.str}/rpc"))
1609 if err != nil {
1610 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1611 return
1612 }
1613 resp, md, err := local_request_FlowCombination_RpcPathSingleNestedRpc_0(annotatedContext, inboundMarshaler, server, req, pathParams)
1614 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1615 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1616 if err != nil {
1617 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1618 return
1619 }
1620
1621 forward_FlowCombination_RpcPathSingleNestedRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1622
1623 })
1624
1625 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1626 ctx, cancel := context.WithCancel(req.Context())
1627 defer cancel()
1628 var stream runtime.ServerTransportStream
1629 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1630 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1631 var err error
1632 var annotatedContext context.Context
1633 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested/{a.str}/{b}/rpc"))
1634 if err != nil {
1635 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1636 return
1637 }
1638 resp, md, err := local_request_FlowCombination_RpcPathNestedRpc_0(annotatedContext, inboundMarshaler, server, req, pathParams)
1639 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1640 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1641 if err != nil {
1642 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1643 return
1644 }
1645
1646 forward_FlowCombination_RpcPathNestedRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1647
1648 })
1649
1650 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1651 ctx, cancel := context.WithCancel(req.Context())
1652 defer cancel()
1653 var stream runtime.ServerTransportStream
1654 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1655 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1656 var err error
1657 var annotatedContext context.Context
1658 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested1/{a.str}/rpc"))
1659 if err != nil {
1660 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1661 return
1662 }
1663 resp, md, err := local_request_FlowCombination_RpcPathNestedRpc_1(annotatedContext, inboundMarshaler, server, req, pathParams)
1664 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1665 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1666 if err != nil {
1667 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1668 return
1669 }
1670
1671 forward_FlowCombination_RpcPathNestedRpc_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1672
1673 })
1674
1675 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1676 ctx, cancel := context.WithCancel(req.Context())
1677 defer cancel()
1678 var stream runtime.ServerTransportStream
1679 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
1680 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1681 var err error
1682 var annotatedContext context.Context
1683 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested2/{a.str}/rpc"))
1684 if err != nil {
1685 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1686 return
1687 }
1688 resp, md, err := local_request_FlowCombination_RpcPathNestedRpc_2(annotatedContext, inboundMarshaler, server, req, pathParams)
1689 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
1690 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1691 if err != nil {
1692 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1693 return
1694 }
1695
1696 forward_FlowCombination_RpcPathNestedRpc_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1697
1698 })
1699
1700 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1701 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1702 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1703 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1704 return
1705 })
1706
1707 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1708 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1709 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1710 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1711 return
1712 })
1713
1714 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1715 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1716 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1717 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1718 return
1719 })
1720
1721 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1722 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1723 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1724 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1725 return
1726 })
1727
1728 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1729 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1730 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1731 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1732 return
1733 })
1734
1735 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1736 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1737 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1738 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1739 return
1740 })
1741
1742 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1743 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1744 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1745 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1746 return
1747 })
1748
1749 mux.Handle("POST", pattern_FlowCombination_RpcPathSingleNestedStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1750 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1751 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1752 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1753 return
1754 })
1755
1756 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1757 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1758 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1759 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1760 return
1761 })
1762
1763 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1764 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1765 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1766 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1767 return
1768 })
1769
1770 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1771 err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
1772 _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1773 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1774 return
1775 })
1776
1777 return nil
1778 }
1779
1780
1781
1782 func RegisterFlowCombinationHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
1783 conn, err := grpc.DialContext(ctx, endpoint, opts...)
1784 if err != nil {
1785 return err
1786 }
1787 defer func() {
1788 if err != nil {
1789 if cerr := conn.Close(); cerr != nil {
1790 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
1791 }
1792 return
1793 }
1794 go func() {
1795 <-ctx.Done()
1796 if cerr := conn.Close(); cerr != nil {
1797 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
1798 }
1799 }()
1800 }()
1801
1802 return RegisterFlowCombinationHandler(ctx, mux, conn)
1803 }
1804
1805
1806
1807 func RegisterFlowCombinationHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
1808 return RegisterFlowCombinationHandlerClient(ctx, mux, NewFlowCombinationClient(conn))
1809 }
1810
1811
1812
1813
1814
1815
1816 func RegisterFlowCombinationHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FlowCombinationClient) error {
1817
1818 mux.Handle("POST", pattern_FlowCombination_RpcEmptyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1819 ctx, cancel := context.WithCancel(req.Context())
1820 defer cancel()
1821 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1822 var err error
1823 var annotatedContext context.Context
1824 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyRpc", runtime.WithHTTPPathPattern("/rpc/empty/rpc"))
1825 if err != nil {
1826 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1827 return
1828 }
1829 resp, md, err := request_FlowCombination_RpcEmptyRpc_0(annotatedContext, inboundMarshaler, client, req, pathParams)
1830 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1831 if err != nil {
1832 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1833 return
1834 }
1835
1836 forward_FlowCombination_RpcEmptyRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1837
1838 })
1839
1840 mux.Handle("POST", pattern_FlowCombination_RpcEmptyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1841 ctx, cancel := context.WithCancel(req.Context())
1842 defer cancel()
1843 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1844 var err error
1845 var annotatedContext context.Context
1846 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyStream", runtime.WithHTTPPathPattern("/rpc/empty/stream"))
1847 if err != nil {
1848 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1849 return
1850 }
1851 resp, md, err := request_FlowCombination_RpcEmptyStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
1852 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1853 if err != nil {
1854 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1855 return
1856 }
1857
1858 forward_FlowCombination_RpcEmptyStream_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
1859
1860 })
1861
1862 mux.Handle("POST", pattern_FlowCombination_StreamEmptyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1863 ctx, cancel := context.WithCancel(req.Context())
1864 defer cancel()
1865 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1866 var err error
1867 var annotatedContext context.Context
1868 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/StreamEmptyRpc", runtime.WithHTTPPathPattern("/stream/empty/rpc"))
1869 if err != nil {
1870 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1871 return
1872 }
1873 resp, md, err := request_FlowCombination_StreamEmptyRpc_0(annotatedContext, inboundMarshaler, client, req, pathParams)
1874 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1875 if err != nil {
1876 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1877 return
1878 }
1879
1880 forward_FlowCombination_StreamEmptyRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1881
1882 })
1883
1884 mux.Handle("POST", pattern_FlowCombination_StreamEmptyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1885 ctx, cancel := context.WithCancel(req.Context())
1886 defer cancel()
1887 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1888 var err error
1889 var annotatedContext context.Context
1890 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/StreamEmptyStream", runtime.WithHTTPPathPattern("/stream/empty/stream"))
1891 if err != nil {
1892 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1893 return
1894 }
1895 resp, md, err := request_FlowCombination_StreamEmptyStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
1896 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1897 if err != nil {
1898 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1899 return
1900 }
1901
1902 forward_FlowCombination_StreamEmptyStream_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
1903
1904 })
1905
1906 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1907 ctx, cancel := context.WithCancel(req.Context())
1908 defer cancel()
1909 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1910 var err error
1911 var annotatedContext context.Context
1912 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/rpc"))
1913 if err != nil {
1914 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1915 return
1916 }
1917 resp, md, err := request_FlowCombination_RpcBodyRpc_0(annotatedContext, inboundMarshaler, client, req, pathParams)
1918 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1919 if err != nil {
1920 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1921 return
1922 }
1923
1924 forward_FlowCombination_RpcBodyRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1925
1926 })
1927
1928 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1929 ctx, cancel := context.WithCancel(req.Context())
1930 defer cancel()
1931 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1932 var err error
1933 var annotatedContext context.Context
1934 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/path/{a}/{b}/{c}/rpc"))
1935 if err != nil {
1936 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1937 return
1938 }
1939 resp, md, err := request_FlowCombination_RpcBodyRpc_1(annotatedContext, inboundMarshaler, client, req, pathParams)
1940 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1941 if err != nil {
1942 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1943 return
1944 }
1945
1946 forward_FlowCombination_RpcBodyRpc_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1947
1948 })
1949
1950 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1951 ctx, cancel := context.WithCancel(req.Context())
1952 defer cancel()
1953 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1954 var err error
1955 var annotatedContext context.Context
1956 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/query/rpc"))
1957 if err != nil {
1958 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1959 return
1960 }
1961 resp, md, err := request_FlowCombination_RpcBodyRpc_2(annotatedContext, inboundMarshaler, client, req, pathParams)
1962 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1963 if err != nil {
1964 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1965 return
1966 }
1967
1968 forward_FlowCombination_RpcBodyRpc_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1969
1970 })
1971
1972 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1973 ctx, cancel := context.WithCancel(req.Context())
1974 defer cancel()
1975 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1976 var err error
1977 var annotatedContext context.Context
1978 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/path/{a}/{b}/rpc"))
1979 if err != nil {
1980 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1981 return
1982 }
1983 resp, md, err := request_FlowCombination_RpcBodyRpc_3(annotatedContext, inboundMarshaler, client, req, pathParams)
1984 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
1985 if err != nil {
1986 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
1987 return
1988 }
1989
1990 forward_FlowCombination_RpcBodyRpc_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1991
1992 })
1993
1994 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1995 ctx, cancel := context.WithCancel(req.Context())
1996 defer cancel()
1997 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1998 var err error
1999 var annotatedContext context.Context
2000 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/query/rpc"))
2001 if err != nil {
2002 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2003 return
2004 }
2005 resp, md, err := request_FlowCombination_RpcBodyRpc_4(annotatedContext, inboundMarshaler, client, req, pathParams)
2006 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2007 if err != nil {
2008 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2009 return
2010 }
2011
2012 forward_FlowCombination_RpcBodyRpc_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2013
2014 })
2015
2016 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2017 ctx, cancel := context.WithCancel(req.Context())
2018 defer cancel()
2019 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2020 var err error
2021 var annotatedContext context.Context
2022 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/body/path/{a}/query/rpc"))
2023 if err != nil {
2024 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2025 return
2026 }
2027 resp, md, err := request_FlowCombination_RpcBodyRpc_5(annotatedContext, inboundMarshaler, client, req, pathParams)
2028 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2029 if err != nil {
2030 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2031 return
2032 }
2033
2034 forward_FlowCombination_RpcBodyRpc_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2035
2036 })
2037
2038 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2039 ctx, cancel := context.WithCancel(req.Context())
2040 defer cancel()
2041 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2042 var err error
2043 var annotatedContext context.Context
2044 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc", runtime.WithHTTPPathPattern("/rpc/path/{a}/query/rpc"))
2045 if err != nil {
2046 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2047 return
2048 }
2049 resp, md, err := request_FlowCombination_RpcBodyRpc_6(annotatedContext, inboundMarshaler, client, req, pathParams)
2050 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2051 if err != nil {
2052 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2053 return
2054 }
2055
2056 forward_FlowCombination_RpcBodyRpc_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2057
2058 })
2059
2060 mux.Handle("POST", pattern_FlowCombination_RpcPathSingleNestedRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2061 ctx, cancel := context.WithCancel(req.Context())
2062 defer cancel()
2063 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2064 var err error
2065 var annotatedContext context.Context
2066 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested/{a.str}/rpc"))
2067 if err != nil {
2068 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2069 return
2070 }
2071 resp, md, err := request_FlowCombination_RpcPathSingleNestedRpc_0(annotatedContext, inboundMarshaler, client, req, pathParams)
2072 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2073 if err != nil {
2074 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2075 return
2076 }
2077
2078 forward_FlowCombination_RpcPathSingleNestedRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2079
2080 })
2081
2082 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2083 ctx, cancel := context.WithCancel(req.Context())
2084 defer cancel()
2085 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2086 var err error
2087 var annotatedContext context.Context
2088 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested/{a.str}/{b}/rpc"))
2089 if err != nil {
2090 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2091 return
2092 }
2093 resp, md, err := request_FlowCombination_RpcPathNestedRpc_0(annotatedContext, inboundMarshaler, client, req, pathParams)
2094 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2095 if err != nil {
2096 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2097 return
2098 }
2099
2100 forward_FlowCombination_RpcPathNestedRpc_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2101
2102 })
2103
2104 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2105 ctx, cancel := context.WithCancel(req.Context())
2106 defer cancel()
2107 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2108 var err error
2109 var annotatedContext context.Context
2110 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested1/{a.str}/rpc"))
2111 if err != nil {
2112 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2113 return
2114 }
2115 resp, md, err := request_FlowCombination_RpcPathNestedRpc_1(annotatedContext, inboundMarshaler, client, req, pathParams)
2116 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2117 if err != nil {
2118 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2119 return
2120 }
2121
2122 forward_FlowCombination_RpcPathNestedRpc_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2123
2124 })
2125
2126 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2127 ctx, cancel := context.WithCancel(req.Context())
2128 defer cancel()
2129 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2130 var err error
2131 var annotatedContext context.Context
2132 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc", runtime.WithHTTPPathPattern("/rpc/path-nested2/{a.str}/rpc"))
2133 if err != nil {
2134 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2135 return
2136 }
2137 resp, md, err := request_FlowCombination_RpcPathNestedRpc_2(annotatedContext, inboundMarshaler, client, req, pathParams)
2138 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2139 if err != nil {
2140 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2141 return
2142 }
2143
2144 forward_FlowCombination_RpcPathNestedRpc_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2145
2146 })
2147
2148 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2149 ctx, cancel := context.WithCancel(req.Context())
2150 defer cancel()
2151 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2152 var err error
2153 var annotatedContext context.Context
2154 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/body/stream"))
2155 if err != nil {
2156 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2157 return
2158 }
2159 resp, md, err := request_FlowCombination_RpcBodyStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
2160 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2161 if err != nil {
2162 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2163 return
2164 }
2165
2166 forward_FlowCombination_RpcBodyStream_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2167
2168 })
2169
2170 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2171 ctx, cancel := context.WithCancel(req.Context())
2172 defer cancel()
2173 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2174 var err error
2175 var annotatedContext context.Context
2176 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/path/{a}/{b}/{c}/stream"))
2177 if err != nil {
2178 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2179 return
2180 }
2181 resp, md, err := request_FlowCombination_RpcBodyStream_1(annotatedContext, inboundMarshaler, client, req, pathParams)
2182 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2183 if err != nil {
2184 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2185 return
2186 }
2187
2188 forward_FlowCombination_RpcBodyStream_1(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2189
2190 })
2191
2192 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2193 ctx, cancel := context.WithCancel(req.Context())
2194 defer cancel()
2195 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2196 var err error
2197 var annotatedContext context.Context
2198 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/query/stream"))
2199 if err != nil {
2200 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2201 return
2202 }
2203 resp, md, err := request_FlowCombination_RpcBodyStream_2(annotatedContext, inboundMarshaler, client, req, pathParams)
2204 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2205 if err != nil {
2206 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2207 return
2208 }
2209
2210 forward_FlowCombination_RpcBodyStream_2(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2211
2212 })
2213
2214 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2215 ctx, cancel := context.WithCancel(req.Context())
2216 defer cancel()
2217 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2218 var err error
2219 var annotatedContext context.Context
2220 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/body/path/{a}/{b}/stream"))
2221 if err != nil {
2222 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2223 return
2224 }
2225 resp, md, err := request_FlowCombination_RpcBodyStream_3(annotatedContext, inboundMarshaler, client, req, pathParams)
2226 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2227 if err != nil {
2228 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2229 return
2230 }
2231
2232 forward_FlowCombination_RpcBodyStream_3(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2233
2234 })
2235
2236 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2237 ctx, cancel := context.WithCancel(req.Context())
2238 defer cancel()
2239 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2240 var err error
2241 var annotatedContext context.Context
2242 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/body/query/stream"))
2243 if err != nil {
2244 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2245 return
2246 }
2247 resp, md, err := request_FlowCombination_RpcBodyStream_4(annotatedContext, inboundMarshaler, client, req, pathParams)
2248 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2249 if err != nil {
2250 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2251 return
2252 }
2253
2254 forward_FlowCombination_RpcBodyStream_4(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2255
2256 })
2257
2258 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2259 ctx, cancel := context.WithCancel(req.Context())
2260 defer cancel()
2261 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2262 var err error
2263 var annotatedContext context.Context
2264 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/body/path/{a}/query/stream"))
2265 if err != nil {
2266 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2267 return
2268 }
2269 resp, md, err := request_FlowCombination_RpcBodyStream_5(annotatedContext, inboundMarshaler, client, req, pathParams)
2270 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2271 if err != nil {
2272 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2273 return
2274 }
2275
2276 forward_FlowCombination_RpcBodyStream_5(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2277
2278 })
2279
2280 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2281 ctx, cancel := context.WithCancel(req.Context())
2282 defer cancel()
2283 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2284 var err error
2285 var annotatedContext context.Context
2286 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream", runtime.WithHTTPPathPattern("/rpc/path/{a}/query/stream"))
2287 if err != nil {
2288 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2289 return
2290 }
2291 resp, md, err := request_FlowCombination_RpcBodyStream_6(annotatedContext, inboundMarshaler, client, req, pathParams)
2292 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2293 if err != nil {
2294 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2295 return
2296 }
2297
2298 forward_FlowCombination_RpcBodyStream_6(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2299
2300 })
2301
2302 mux.Handle("POST", pattern_FlowCombination_RpcPathSingleNestedStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2303 ctx, cancel := context.WithCancel(req.Context())
2304 defer cancel()
2305 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2306 var err error
2307 var annotatedContext context.Context
2308 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedStream", runtime.WithHTTPPathPattern("/rpc/path-nested/{a.str}/stream"))
2309 if err != nil {
2310 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2311 return
2312 }
2313 resp, md, err := request_FlowCombination_RpcPathSingleNestedStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
2314 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2315 if err != nil {
2316 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2317 return
2318 }
2319
2320 forward_FlowCombination_RpcPathSingleNestedStream_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2321
2322 })
2323
2324 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2325 ctx, cancel := context.WithCancel(req.Context())
2326 defer cancel()
2327 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2328 var err error
2329 var annotatedContext context.Context
2330 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedStream", runtime.WithHTTPPathPattern("/rpc/path-nested/{a.str}/{b}/stream"))
2331 if err != nil {
2332 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2333 return
2334 }
2335 resp, md, err := request_FlowCombination_RpcPathNestedStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
2336 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2337 if err != nil {
2338 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2339 return
2340 }
2341
2342 forward_FlowCombination_RpcPathNestedStream_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2343
2344 })
2345
2346 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2347 ctx, cancel := context.WithCancel(req.Context())
2348 defer cancel()
2349 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2350 var err error
2351 var annotatedContext context.Context
2352 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedStream", runtime.WithHTTPPathPattern("/rpc/path-nested1/{a.str}/stream"))
2353 if err != nil {
2354 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2355 return
2356 }
2357 resp, md, err := request_FlowCombination_RpcPathNestedStream_1(annotatedContext, inboundMarshaler, client, req, pathParams)
2358 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2359 if err != nil {
2360 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2361 return
2362 }
2363
2364 forward_FlowCombination_RpcPathNestedStream_1(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2365
2366 })
2367
2368 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2369 ctx, cancel := context.WithCancel(req.Context())
2370 defer cancel()
2371 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2372 var err error
2373 var annotatedContext context.Context
2374 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedStream", runtime.WithHTTPPathPattern("/rpc/path-nested2/{a.str}/stream"))
2375 if err != nil {
2376 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2377 return
2378 }
2379 resp, md, err := request_FlowCombination_RpcPathNestedStream_2(annotatedContext, inboundMarshaler, client, req, pathParams)
2380 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
2381 if err != nil {
2382 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
2383 return
2384 }
2385
2386 forward_FlowCombination_RpcPathNestedStream_2(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
2387
2388 })
2389
2390 return nil
2391 }
2392
2393 var (
2394 pattern_FlowCombination_RpcEmptyRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"rpc", "empty"}, ""))
2395
2396 pattern_FlowCombination_RpcEmptyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"rpc", "empty", "stream"}, ""))
2397
2398 pattern_FlowCombination_StreamEmptyRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"stream", "empty", "rpc"}, ""))
2399
2400 pattern_FlowCombination_StreamEmptyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"stream", "empty"}, ""))
2401
2402 pattern_FlowCombination_RpcBodyRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"rpc", "body"}, ""))
2403
2404 pattern_FlowCombination_RpcBodyRpc_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 2, 0}, []string{"rpc", "path", "a", "b", "c"}, ""))
2405
2406 pattern_FlowCombination_RpcBodyRpc_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"rpc", "query"}, ""))
2407
2408 pattern_FlowCombination_RpcBodyRpc_3 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 2, 0}, []string{"rpc", "body", "path", "a", "b"}, ""))
2409
2410 pattern_FlowCombination_RpcBodyRpc_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 0}, []string{"rpc", "body", "query"}, ""))
2411
2412 pattern_FlowCombination_RpcBodyRpc_5 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 2, 0}, []string{"rpc", "body", "path", "a", "query"}, ""))
2413
2414 pattern_FlowCombination_RpcBodyRpc_6 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 2, 0}, []string{"rpc", "path", "a", "query"}, ""))
2415
2416 pattern_FlowCombination_RpcPathSingleNestedRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 0}, []string{"rpc", "path-nested", "a.str"}, ""))
2417
2418 pattern_FlowCombination_RpcPathNestedRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3, 2, 0}, []string{"rpc", "path-nested", "a.str", "b"}, ""))
2419
2420 pattern_FlowCombination_RpcPathNestedRpc_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 0}, []string{"rpc", "path-nested1", "a.str"}, ""))
2421
2422 pattern_FlowCombination_RpcPathNestedRpc_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 0}, []string{"rpc", "path-nested2", "a.str"}, ""))
2423
2424 pattern_FlowCombination_RpcBodyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"rpc", "body", "stream"}, ""))
2425
2426 pattern_FlowCombination_RpcBodyStream_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"rpc", "path", "a", "b", "c", "stream"}, ""))
2427
2428 pattern_FlowCombination_RpcBodyStream_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"rpc", "query", "stream"}, ""))
2429
2430 pattern_FlowCombination_RpcBodyStream_3 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"rpc", "body", "path", "a", "b", "stream"}, ""))
2431
2432 pattern_FlowCombination_RpcBodyStream_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"rpc", "body", "query", "stream"}, ""))
2433
2434 pattern_FlowCombination_RpcBodyStream_5 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 2, 5}, []string{"rpc", "body", "path", "a", "query", "stream"}, ""))
2435
2436 pattern_FlowCombination_RpcBodyStream_6 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 2, 4}, []string{"rpc", "path", "a", "query", "stream"}, ""))
2437
2438 pattern_FlowCombination_RpcPathSingleNestedStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"rpc", "path-nested", "a.str", "stream"}, ""))
2439
2440 pattern_FlowCombination_RpcPathNestedStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"rpc", "path-nested", "a.str", "b", "stream"}, ""))
2441
2442 pattern_FlowCombination_RpcPathNestedStream_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"rpc", "path-nested1", "a.str", "stream"}, ""))
2443
2444 pattern_FlowCombination_RpcPathNestedStream_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"rpc", "path-nested2", "a.str", "stream"}, ""))
2445 )
2446
2447 var (
2448 forward_FlowCombination_RpcEmptyRpc_0 = runtime.ForwardResponseMessage
2449
2450 forward_FlowCombination_RpcEmptyStream_0 = runtime.ForwardResponseStream
2451
2452 forward_FlowCombination_StreamEmptyRpc_0 = runtime.ForwardResponseMessage
2453
2454 forward_FlowCombination_StreamEmptyStream_0 = runtime.ForwardResponseStream
2455
2456 forward_FlowCombination_RpcBodyRpc_0 = runtime.ForwardResponseMessage
2457
2458 forward_FlowCombination_RpcBodyRpc_1 = runtime.ForwardResponseMessage
2459
2460 forward_FlowCombination_RpcBodyRpc_2 = runtime.ForwardResponseMessage
2461
2462 forward_FlowCombination_RpcBodyRpc_3 = runtime.ForwardResponseMessage
2463
2464 forward_FlowCombination_RpcBodyRpc_4 = runtime.ForwardResponseMessage
2465
2466 forward_FlowCombination_RpcBodyRpc_5 = runtime.ForwardResponseMessage
2467
2468 forward_FlowCombination_RpcBodyRpc_6 = runtime.ForwardResponseMessage
2469
2470 forward_FlowCombination_RpcPathSingleNestedRpc_0 = runtime.ForwardResponseMessage
2471
2472 forward_FlowCombination_RpcPathNestedRpc_0 = runtime.ForwardResponseMessage
2473
2474 forward_FlowCombination_RpcPathNestedRpc_1 = runtime.ForwardResponseMessage
2475
2476 forward_FlowCombination_RpcPathNestedRpc_2 = runtime.ForwardResponseMessage
2477
2478 forward_FlowCombination_RpcBodyStream_0 = runtime.ForwardResponseStream
2479
2480 forward_FlowCombination_RpcBodyStream_1 = runtime.ForwardResponseStream
2481
2482 forward_FlowCombination_RpcBodyStream_2 = runtime.ForwardResponseStream
2483
2484 forward_FlowCombination_RpcBodyStream_3 = runtime.ForwardResponseStream
2485
2486 forward_FlowCombination_RpcBodyStream_4 = runtime.ForwardResponseStream
2487
2488 forward_FlowCombination_RpcBodyStream_5 = runtime.ForwardResponseStream
2489
2490 forward_FlowCombination_RpcBodyStream_6 = runtime.ForwardResponseStream
2491
2492 forward_FlowCombination_RpcPathSingleNestedStream_0 = runtime.ForwardResponseStream
2493
2494 forward_FlowCombination_RpcPathNestedStream_0 = runtime.ForwardResponseStream
2495
2496 forward_FlowCombination_RpcPathNestedStream_1 = runtime.ForwardResponseStream
2497
2498 forward_FlowCombination_RpcPathNestedStream_2 = runtime.ForwardResponseStream
2499 )
2500
View as plain text