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