1// Code generated by protoc-gen-grpc-gateway 2// source: examples/examplepb/flow_combination.proto 3// DO NOT EDIT! 4 5/* 6Package examplepb is a reverse proxy. 7 8It translates gRPC into RESTful JSON APIs. 9*/ 10package examplepb 11 12import ( 13 "io" 14 "net/http" 15 16 "github.com/golang/protobuf/proto" 17 "github.com/grpc-ecosystem/grpc-gateway/runtime" 18 "github.com/grpc-ecosystem/grpc-gateway/utilities" 19 "golang.org/x/net/context" 20 "google.golang.org/grpc" 21 "google.golang.org/grpc/codes" 22 "google.golang.org/grpc/grpclog" 23) 24 25var _ codes.Code 26var _ io.Reader 27var _ = runtime.String 28var _ = utilities.NewDoubleArray 29 30func request_FlowCombination_RpcEmptyRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 31 var protoReq EmptyProto 32 var metadata runtime.ServerMetadata 33 34 msg, err := client.RpcEmptyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 35 return msg, metadata, err 36 37} 38 39func request_FlowCombination_RpcEmptyStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcEmptyStreamClient, runtime.ServerMetadata, error) { 40 var protoReq EmptyProto 41 var metadata runtime.ServerMetadata 42 43 stream, err := client.RpcEmptyStream(ctx, &protoReq) 44 if err != nil { 45 return nil, metadata, err 46 } 47 header, err := stream.Header() 48 if err != nil { 49 return nil, metadata, err 50 } 51 metadata.HeaderMD = header 52 return stream, metadata, nil 53 54} 55 56func request_FlowCombination_StreamEmptyRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 57 var metadata runtime.ServerMetadata 58 stream, err := client.StreamEmptyRpc(ctx) 59 if err != nil { 60 grpclog.Printf("Failed to start streaming: %v", err) 61 return nil, metadata, err 62 } 63 dec := marshaler.NewDecoder(req.Body) 64 for { 65 var protoReq EmptyProto 66 err = dec.Decode(&protoReq) 67 if err == io.EOF { 68 break 69 } 70 if err != nil { 71 grpclog.Printf("Failed to decode request: %v", err) 72 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 73 } 74 if err = stream.Send(&protoReq); err != nil { 75 grpclog.Printf("Failed to send request: %v", err) 76 return nil, metadata, err 77 } 78 } 79 80 if err := stream.CloseSend(); err != nil { 81 grpclog.Printf("Failed to terminate client stream: %v", err) 82 return nil, metadata, err 83 } 84 header, err := stream.Header() 85 if err != nil { 86 grpclog.Printf("Failed to get header from client: %v", err) 87 return nil, metadata, err 88 } 89 metadata.HeaderMD = header 90 91 msg, err := stream.CloseAndRecv() 92 metadata.TrailerMD = stream.Trailer() 93 return msg, metadata, err 94 95} 96 97func request_FlowCombination_StreamEmptyStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_StreamEmptyStreamClient, runtime.ServerMetadata, error) { 98 var metadata runtime.ServerMetadata 99 stream, err := client.StreamEmptyStream(ctx) 100 if err != nil { 101 grpclog.Printf("Failed to start streaming: %v", err) 102 return nil, metadata, err 103 } 104 dec := marshaler.NewDecoder(req.Body) 105 handleSend := func() error { 106 var protoReq EmptyProto 107 err = dec.Decode(&protoReq) 108 if err == io.EOF { 109 return err 110 } 111 if err != nil { 112 grpclog.Printf("Failed to decode request: %v", err) 113 return err 114 } 115 if err = stream.Send(&protoReq); err != nil { 116 grpclog.Printf("Failed to send request: %v", err) 117 return err 118 } 119 return nil 120 } 121 if err := handleSend(); err != nil { 122 if cerr := stream.CloseSend(); cerr != nil { 123 grpclog.Printf("Failed to terminate client stream: %v", cerr) 124 } 125 if err == io.EOF { 126 return stream, metadata, nil 127 } 128 return nil, metadata, err 129 } 130 go func() { 131 for { 132 if err := handleSend(); err != nil { 133 break 134 } 135 } 136 if err := stream.CloseSend(); err != nil { 137 grpclog.Printf("Failed to terminate client stream: %v", err) 138 } 139 }() 140 header, err := stream.Header() 141 if err != nil { 142 grpclog.Printf("Failed to get header from client: %v", err) 143 return nil, metadata, err 144 } 145 metadata.HeaderMD = header 146 return stream, metadata, nil 147} 148 149func request_FlowCombination_RpcBodyRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 150 var protoReq NonEmptyProto 151 var metadata runtime.ServerMetadata 152 153 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 154 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 155 } 156 157 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 158 return msg, metadata, err 159 160} 161 162func request_FlowCombination_RpcBodyRpc_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 163 var protoReq NonEmptyProto 164 var metadata runtime.ServerMetadata 165 166 var ( 167 val string 168 ok bool 169 err error 170 _ = err 171 ) 172 173 val, ok = pathParams["a"] 174 if !ok { 175 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 176 } 177 178 protoReq.A, err = runtime.String(val) 179 180 if err != nil { 181 return nil, metadata, err 182 } 183 184 val, ok = pathParams["b"] 185 if !ok { 186 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "b") 187 } 188 189 protoReq.B, err = runtime.String(val) 190 191 if err != nil { 192 return nil, metadata, err 193 } 194 195 val, ok = pathParams["c"] 196 if !ok { 197 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "c") 198 } 199 200 protoReq.C, err = runtime.String(val) 201 202 if err != nil { 203 return nil, metadata, err 204 } 205 206 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 207 return msg, metadata, err 208 209} 210 211var ( 212 filter_FlowCombination_RpcBodyRpc_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} 213) 214 215func request_FlowCombination_RpcBodyRpc_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 216 var protoReq NonEmptyProto 217 var metadata runtime.ServerMetadata 218 219 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyRpc_2); err != nil { 220 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 221 } 222 223 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 224 return msg, metadata, err 225 226} 227 228func request_FlowCombination_RpcBodyRpc_3(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 229 var protoReq NonEmptyProto 230 var metadata runtime.ServerMetadata 231 232 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 233 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 234 } 235 236 var ( 237 val string 238 ok bool 239 err error 240 _ = err 241 ) 242 243 val, ok = pathParams["a"] 244 if !ok { 245 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 246 } 247 248 protoReq.A, err = runtime.String(val) 249 250 if err != nil { 251 return nil, metadata, err 252 } 253 254 val, ok = pathParams["b"] 255 if !ok { 256 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "b") 257 } 258 259 protoReq.B, err = runtime.String(val) 260 261 if err != nil { 262 return nil, metadata, err 263 } 264 265 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 266 return msg, metadata, err 267 268} 269 270var ( 271 filter_FlowCombination_RpcBodyRpc_4 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 272) 273 274func request_FlowCombination_RpcBodyRpc_4(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 275 var protoReq NonEmptyProto 276 var metadata runtime.ServerMetadata 277 278 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 279 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 280 } 281 282 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyRpc_4); err != nil { 283 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 284 } 285 286 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 287 return msg, metadata, err 288 289} 290 291var ( 292 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}} 293) 294 295func request_FlowCombination_RpcBodyRpc_5(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 296 var protoReq NonEmptyProto 297 var metadata runtime.ServerMetadata 298 299 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 300 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 301 } 302 303 var ( 304 val string 305 ok bool 306 err error 307 _ = err 308 ) 309 310 val, ok = pathParams["a"] 311 if !ok { 312 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 313 } 314 315 protoReq.A, err = runtime.String(val) 316 317 if err != nil { 318 return nil, metadata, err 319 } 320 321 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyRpc_5); err != nil { 322 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 323 } 324 325 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 326 return msg, metadata, err 327 328} 329 330var ( 331 filter_FlowCombination_RpcBodyRpc_6 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 332) 333 334func request_FlowCombination_RpcBodyRpc_6(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 335 var protoReq NonEmptyProto 336 var metadata runtime.ServerMetadata 337 338 var ( 339 val string 340 ok bool 341 err error 342 _ = err 343 ) 344 345 val, ok = pathParams["a"] 346 if !ok { 347 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 348 } 349 350 protoReq.A, err = runtime.String(val) 351 352 if err != nil { 353 return nil, metadata, err 354 } 355 356 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyRpc_6); err != nil { 357 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 358 } 359 360 msg, err := client.RpcBodyRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 361 return msg, metadata, err 362 363} 364 365var ( 366 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}} 367) 368 369func request_FlowCombination_RpcPathSingleNestedRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 370 var protoReq SingleNestedProto 371 var metadata runtime.ServerMetadata 372 373 var ( 374 val string 375 ok bool 376 err error 377 _ = err 378 ) 379 380 val, ok = pathParams["a.str"] 381 if !ok { 382 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 383 } 384 385 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 386 387 if err != nil { 388 return nil, metadata, err 389 } 390 391 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathSingleNestedRpc_0); err != nil { 392 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 393 } 394 395 msg, err := client.RpcPathSingleNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 396 return msg, metadata, err 397 398} 399 400var ( 401 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}} 402) 403 404func request_FlowCombination_RpcPathNestedRpc_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 405 var protoReq NestedProto 406 var metadata runtime.ServerMetadata 407 408 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 409 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 410 } 411 412 var ( 413 val string 414 ok bool 415 err error 416 _ = err 417 ) 418 419 val, ok = pathParams["a.str"] 420 if !ok { 421 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 422 } 423 424 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 425 426 if err != nil { 427 return nil, metadata, err 428 } 429 430 val, ok = pathParams["b"] 431 if !ok { 432 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "b") 433 } 434 435 protoReq.B, err = runtime.String(val) 436 437 if err != nil { 438 return nil, metadata, err 439 } 440 441 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathNestedRpc_0); err != nil { 442 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 443 } 444 445 msg, err := client.RpcPathNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 446 return msg, metadata, err 447 448} 449 450var ( 451 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}} 452) 453 454func request_FlowCombination_RpcPathNestedRpc_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 455 var protoReq NestedProto 456 var metadata runtime.ServerMetadata 457 458 var ( 459 val string 460 ok bool 461 err error 462 _ = err 463 ) 464 465 val, ok = pathParams["a.str"] 466 if !ok { 467 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 468 } 469 470 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 471 472 if err != nil { 473 return nil, metadata, err 474 } 475 476 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathNestedRpc_1); err != nil { 477 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 478 } 479 480 msg, err := client.RpcPathNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 481 return msg, metadata, err 482 483} 484 485var ( 486 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}} 487) 488 489func request_FlowCombination_RpcPathNestedRpc_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 490 var protoReq NestedProto 491 var metadata runtime.ServerMetadata 492 493 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 494 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 495 } 496 497 var ( 498 val string 499 ok bool 500 err error 501 _ = err 502 ) 503 504 val, ok = pathParams["a.str"] 505 if !ok { 506 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 507 } 508 509 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 510 511 if err != nil { 512 return nil, metadata, err 513 } 514 515 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathNestedRpc_2); err != nil { 516 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 517 } 518 519 msg, err := client.RpcPathNestedRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 520 return msg, metadata, err 521 522} 523 524func request_FlowCombination_RpcBodyStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 525 var protoReq NonEmptyProto 526 var metadata runtime.ServerMetadata 527 528 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 529 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 530 } 531 532 stream, err := client.RpcBodyStream(ctx, &protoReq) 533 if err != nil { 534 return nil, metadata, err 535 } 536 header, err := stream.Header() 537 if err != nil { 538 return nil, metadata, err 539 } 540 metadata.HeaderMD = header 541 return stream, metadata, nil 542 543} 544 545func request_FlowCombination_RpcBodyStream_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 546 var protoReq NonEmptyProto 547 var metadata runtime.ServerMetadata 548 549 var ( 550 val string 551 ok bool 552 err error 553 _ = err 554 ) 555 556 val, ok = pathParams["a"] 557 if !ok { 558 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 559 } 560 561 protoReq.A, err = runtime.String(val) 562 563 if err != nil { 564 return nil, metadata, err 565 } 566 567 val, ok = pathParams["b"] 568 if !ok { 569 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "b") 570 } 571 572 protoReq.B, err = runtime.String(val) 573 574 if err != nil { 575 return nil, metadata, err 576 } 577 578 val, ok = pathParams["c"] 579 if !ok { 580 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "c") 581 } 582 583 protoReq.C, err = runtime.String(val) 584 585 if err != nil { 586 return nil, metadata, err 587 } 588 589 stream, err := client.RpcBodyStream(ctx, &protoReq) 590 if err != nil { 591 return nil, metadata, err 592 } 593 header, err := stream.Header() 594 if err != nil { 595 return nil, metadata, err 596 } 597 metadata.HeaderMD = header 598 return stream, metadata, nil 599 600} 601 602var ( 603 filter_FlowCombination_RpcBodyStream_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} 604) 605 606func request_FlowCombination_RpcBodyStream_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 607 var protoReq NonEmptyProto 608 var metadata runtime.ServerMetadata 609 610 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyStream_2); err != nil { 611 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 612 } 613 614 stream, err := client.RpcBodyStream(ctx, &protoReq) 615 if err != nil { 616 return nil, metadata, err 617 } 618 header, err := stream.Header() 619 if err != nil { 620 return nil, metadata, err 621 } 622 metadata.HeaderMD = header 623 return stream, metadata, nil 624 625} 626 627func request_FlowCombination_RpcBodyStream_3(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 628 var protoReq NonEmptyProto 629 var metadata runtime.ServerMetadata 630 631 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 632 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 633 } 634 635 var ( 636 val string 637 ok bool 638 err error 639 _ = err 640 ) 641 642 val, ok = pathParams["a"] 643 if !ok { 644 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 645 } 646 647 protoReq.A, err = runtime.String(val) 648 649 if err != nil { 650 return nil, metadata, err 651 } 652 653 val, ok = pathParams["b"] 654 if !ok { 655 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "b") 656 } 657 658 protoReq.B, err = runtime.String(val) 659 660 if err != nil { 661 return nil, metadata, err 662 } 663 664 stream, err := client.RpcBodyStream(ctx, &protoReq) 665 if err != nil { 666 return nil, metadata, err 667 } 668 header, err := stream.Header() 669 if err != nil { 670 return nil, metadata, err 671 } 672 metadata.HeaderMD = header 673 return stream, metadata, nil 674 675} 676 677var ( 678 filter_FlowCombination_RpcBodyStream_4 = &utilities.DoubleArray{Encoding: map[string]int{"c": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 679) 680 681func request_FlowCombination_RpcBodyStream_4(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 682 var protoReq NonEmptyProto 683 var metadata runtime.ServerMetadata 684 685 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 686 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 687 } 688 689 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyStream_4); err != nil { 690 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 691 } 692 693 stream, err := client.RpcBodyStream(ctx, &protoReq) 694 if err != nil { 695 return nil, metadata, err 696 } 697 header, err := stream.Header() 698 if err != nil { 699 return nil, metadata, err 700 } 701 metadata.HeaderMD = header 702 return stream, metadata, nil 703 704} 705 706var ( 707 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}} 708) 709 710func request_FlowCombination_RpcBodyStream_5(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 711 var protoReq NonEmptyProto 712 var metadata runtime.ServerMetadata 713 714 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 715 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 716 } 717 718 var ( 719 val string 720 ok bool 721 err error 722 _ = err 723 ) 724 725 val, ok = pathParams["a"] 726 if !ok { 727 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 728 } 729 730 protoReq.A, err = runtime.String(val) 731 732 if err != nil { 733 return nil, metadata, err 734 } 735 736 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyStream_5); err != nil { 737 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 738 } 739 740 stream, err := client.RpcBodyStream(ctx, &protoReq) 741 if err != nil { 742 return nil, metadata, err 743 } 744 header, err := stream.Header() 745 if err != nil { 746 return nil, metadata, err 747 } 748 metadata.HeaderMD = header 749 return stream, metadata, nil 750 751} 752 753var ( 754 filter_FlowCombination_RpcBodyStream_6 = &utilities.DoubleArray{Encoding: map[string]int{"a": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 755) 756 757func request_FlowCombination_RpcBodyStream_6(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcBodyStreamClient, runtime.ServerMetadata, error) { 758 var protoReq NonEmptyProto 759 var metadata runtime.ServerMetadata 760 761 var ( 762 val string 763 ok bool 764 err error 765 _ = err 766 ) 767 768 val, ok = pathParams["a"] 769 if !ok { 770 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a") 771 } 772 773 protoReq.A, err = runtime.String(val) 774 775 if err != nil { 776 return nil, metadata, err 777 } 778 779 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcBodyStream_6); err != nil { 780 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 781 } 782 783 stream, err := client.RpcBodyStream(ctx, &protoReq) 784 if err != nil { 785 return nil, metadata, err 786 } 787 header, err := stream.Header() 788 if err != nil { 789 return nil, metadata, err 790 } 791 metadata.HeaderMD = header 792 return stream, metadata, nil 793 794} 795 796var ( 797 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}} 798) 799 800func request_FlowCombination_RpcPathSingleNestedStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathSingleNestedStreamClient, runtime.ServerMetadata, error) { 801 var protoReq SingleNestedProto 802 var metadata runtime.ServerMetadata 803 804 var ( 805 val string 806 ok bool 807 err error 808 _ = err 809 ) 810 811 val, ok = pathParams["a.str"] 812 if !ok { 813 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 814 } 815 816 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 817 818 if err != nil { 819 return nil, metadata, err 820 } 821 822 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathSingleNestedStream_0); err != nil { 823 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 824 } 825 826 stream, err := client.RpcPathSingleNestedStream(ctx, &protoReq) 827 if err != nil { 828 return nil, metadata, err 829 } 830 header, err := stream.Header() 831 if err != nil { 832 return nil, metadata, err 833 } 834 metadata.HeaderMD = header 835 return stream, metadata, nil 836 837} 838 839var ( 840 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}} 841) 842 843func request_FlowCombination_RpcPathNestedStream_0(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathNestedStreamClient, runtime.ServerMetadata, error) { 844 var protoReq NestedProto 845 var metadata runtime.ServerMetadata 846 847 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 848 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 849 } 850 851 var ( 852 val string 853 ok bool 854 err error 855 _ = err 856 ) 857 858 val, ok = pathParams["a.str"] 859 if !ok { 860 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 861 } 862 863 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 864 865 if err != nil { 866 return nil, metadata, err 867 } 868 869 val, ok = pathParams["b"] 870 if !ok { 871 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "b") 872 } 873 874 protoReq.B, err = runtime.String(val) 875 876 if err != nil { 877 return nil, metadata, err 878 } 879 880 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathNestedStream_0); err != nil { 881 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 882 } 883 884 stream, err := client.RpcPathNestedStream(ctx, &protoReq) 885 if err != nil { 886 return nil, metadata, err 887 } 888 header, err := stream.Header() 889 if err != nil { 890 return nil, metadata, err 891 } 892 metadata.HeaderMD = header 893 return stream, metadata, nil 894 895} 896 897var ( 898 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}} 899) 900 901func request_FlowCombination_RpcPathNestedStream_1(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathNestedStreamClient, runtime.ServerMetadata, error) { 902 var protoReq NestedProto 903 var metadata runtime.ServerMetadata 904 905 var ( 906 val string 907 ok bool 908 err error 909 _ = err 910 ) 911 912 val, ok = pathParams["a.str"] 913 if !ok { 914 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 915 } 916 917 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 918 919 if err != nil { 920 return nil, metadata, err 921 } 922 923 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathNestedStream_1); err != nil { 924 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 925 } 926 927 stream, err := client.RpcPathNestedStream(ctx, &protoReq) 928 if err != nil { 929 return nil, metadata, err 930 } 931 header, err := stream.Header() 932 if err != nil { 933 return nil, metadata, err 934 } 935 metadata.HeaderMD = header 936 return stream, metadata, nil 937 938} 939 940var ( 941 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}} 942) 943 944func request_FlowCombination_RpcPathNestedStream_2(ctx context.Context, marshaler runtime.Marshaler, client FlowCombinationClient, req *http.Request, pathParams map[string]string) (FlowCombination_RpcPathNestedStreamClient, runtime.ServerMetadata, error) { 945 var protoReq NestedProto 946 var metadata runtime.ServerMetadata 947 948 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.C); err != nil { 949 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 950 } 951 952 var ( 953 val string 954 ok bool 955 err error 956 _ = err 957 ) 958 959 val, ok = pathParams["a.str"] 960 if !ok { 961 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "a.str") 962 } 963 964 err = runtime.PopulateFieldFromPath(&protoReq, "a.str", val) 965 966 if err != nil { 967 return nil, metadata, err 968 } 969 970 if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_FlowCombination_RpcPathNestedStream_2); err != nil { 971 return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err) 972 } 973 974 stream, err := client.RpcPathNestedStream(ctx, &protoReq) 975 if err != nil { 976 return nil, metadata, err 977 } 978 header, err := stream.Header() 979 if err != nil { 980 return nil, metadata, err 981 } 982 metadata.HeaderMD = header 983 return stream, metadata, nil 984 985} 986 987// RegisterFlowCombinationHandlerFromEndpoint is same as RegisterFlowCombinationHandler but 988// automatically dials to "endpoint" and closes the connection when "ctx" gets done. 989func RegisterFlowCombinationHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 990 conn, err := grpc.Dial(endpoint, opts...) 991 if err != nil { 992 return err 993 } 994 defer func() { 995 if err != nil { 996 if cerr := conn.Close(); cerr != nil { 997 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 998 } 999 return 1000 } 1001 go func() { 1002 <-ctx.Done() 1003 if cerr := conn.Close(); cerr != nil { 1004 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 1005 } 1006 }() 1007 }() 1008 1009 return RegisterFlowCombinationHandler(ctx, mux, conn) 1010} 1011 1012// RegisterFlowCombinationHandler registers the http handlers for service FlowCombination to "mux". 1013// The handlers forward requests to the grpc endpoint over "conn". 1014func RegisterFlowCombinationHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1015 client := NewFlowCombinationClient(conn) 1016 1017 mux.Handle("POST", pattern_FlowCombination_RpcEmptyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1018 ctx, cancel := context.WithCancel(ctx) 1019 defer cancel() 1020 if cn, ok := w.(http.CloseNotifier); ok { 1021 go func(done <-chan struct{}, closed <-chan bool) { 1022 select { 1023 case <-done: 1024 case <-closed: 1025 cancel() 1026 } 1027 }(ctx.Done(), cn.CloseNotify()) 1028 } 1029 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1030 rctx, err := runtime.AnnotateContext(ctx, req) 1031 if err != nil { 1032 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1033 } 1034 resp, md, err := request_FlowCombination_RpcEmptyRpc_0(rctx, inboundMarshaler, client, req, pathParams) 1035 ctx = runtime.NewServerMetadataContext(ctx, md) 1036 if err != nil { 1037 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1038 return 1039 } 1040 1041 forward_FlowCombination_RpcEmptyRpc_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1042 1043 }) 1044 1045 mux.Handle("POST", pattern_FlowCombination_RpcEmptyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1046 ctx, cancel := context.WithCancel(ctx) 1047 defer cancel() 1048 if cn, ok := w.(http.CloseNotifier); ok { 1049 go func(done <-chan struct{}, closed <-chan bool) { 1050 select { 1051 case <-done: 1052 case <-closed: 1053 cancel() 1054 } 1055 }(ctx.Done(), cn.CloseNotify()) 1056 } 1057 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1058 rctx, err := runtime.AnnotateContext(ctx, req) 1059 if err != nil { 1060 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1061 } 1062 resp, md, err := request_FlowCombination_RpcEmptyStream_0(rctx, inboundMarshaler, client, req, pathParams) 1063 ctx = runtime.NewServerMetadataContext(ctx, md) 1064 if err != nil { 1065 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1066 return 1067 } 1068 1069 forward_FlowCombination_RpcEmptyStream_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1070 1071 }) 1072 1073 mux.Handle("POST", pattern_FlowCombination_StreamEmptyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1074 ctx, cancel := context.WithCancel(ctx) 1075 defer cancel() 1076 if cn, ok := w.(http.CloseNotifier); ok { 1077 go func(done <-chan struct{}, closed <-chan bool) { 1078 select { 1079 case <-done: 1080 case <-closed: 1081 cancel() 1082 } 1083 }(ctx.Done(), cn.CloseNotify()) 1084 } 1085 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1086 rctx, err := runtime.AnnotateContext(ctx, req) 1087 if err != nil { 1088 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1089 } 1090 resp, md, err := request_FlowCombination_StreamEmptyRpc_0(rctx, inboundMarshaler, client, req, pathParams) 1091 ctx = runtime.NewServerMetadataContext(ctx, md) 1092 if err != nil { 1093 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1094 return 1095 } 1096 1097 forward_FlowCombination_StreamEmptyRpc_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1098 1099 }) 1100 1101 mux.Handle("POST", pattern_FlowCombination_StreamEmptyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1102 ctx, cancel := context.WithCancel(ctx) 1103 defer cancel() 1104 if cn, ok := w.(http.CloseNotifier); ok { 1105 go func(done <-chan struct{}, closed <-chan bool) { 1106 select { 1107 case <-done: 1108 case <-closed: 1109 cancel() 1110 } 1111 }(ctx.Done(), cn.CloseNotify()) 1112 } 1113 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1114 rctx, err := runtime.AnnotateContext(ctx, req) 1115 if err != nil { 1116 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1117 } 1118 resp, md, err := request_FlowCombination_StreamEmptyStream_0(rctx, inboundMarshaler, client, req, pathParams) 1119 ctx = runtime.NewServerMetadataContext(ctx, md) 1120 if err != nil { 1121 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1122 return 1123 } 1124 1125 forward_FlowCombination_StreamEmptyStream_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1126 1127 }) 1128 1129 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1130 ctx, cancel := context.WithCancel(ctx) 1131 defer cancel() 1132 if cn, ok := w.(http.CloseNotifier); ok { 1133 go func(done <-chan struct{}, closed <-chan bool) { 1134 select { 1135 case <-done: 1136 case <-closed: 1137 cancel() 1138 } 1139 }(ctx.Done(), cn.CloseNotify()) 1140 } 1141 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1142 rctx, err := runtime.AnnotateContext(ctx, req) 1143 if err != nil { 1144 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1145 } 1146 resp, md, err := request_FlowCombination_RpcBodyRpc_0(rctx, inboundMarshaler, client, req, pathParams) 1147 ctx = runtime.NewServerMetadataContext(ctx, md) 1148 if err != nil { 1149 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1150 return 1151 } 1152 1153 forward_FlowCombination_RpcBodyRpc_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1154 1155 }) 1156 1157 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1158 ctx, cancel := context.WithCancel(ctx) 1159 defer cancel() 1160 if cn, ok := w.(http.CloseNotifier); ok { 1161 go func(done <-chan struct{}, closed <-chan bool) { 1162 select { 1163 case <-done: 1164 case <-closed: 1165 cancel() 1166 } 1167 }(ctx.Done(), cn.CloseNotify()) 1168 } 1169 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1170 rctx, err := runtime.AnnotateContext(ctx, req) 1171 if err != nil { 1172 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1173 } 1174 resp, md, err := request_FlowCombination_RpcBodyRpc_1(rctx, inboundMarshaler, client, req, pathParams) 1175 ctx = runtime.NewServerMetadataContext(ctx, md) 1176 if err != nil { 1177 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1178 return 1179 } 1180 1181 forward_FlowCombination_RpcBodyRpc_1(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1182 1183 }) 1184 1185 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1186 ctx, cancel := context.WithCancel(ctx) 1187 defer cancel() 1188 if cn, ok := w.(http.CloseNotifier); ok { 1189 go func(done <-chan struct{}, closed <-chan bool) { 1190 select { 1191 case <-done: 1192 case <-closed: 1193 cancel() 1194 } 1195 }(ctx.Done(), cn.CloseNotify()) 1196 } 1197 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1198 rctx, err := runtime.AnnotateContext(ctx, req) 1199 if err != nil { 1200 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1201 } 1202 resp, md, err := request_FlowCombination_RpcBodyRpc_2(rctx, inboundMarshaler, client, req, pathParams) 1203 ctx = runtime.NewServerMetadataContext(ctx, md) 1204 if err != nil { 1205 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1206 return 1207 } 1208 1209 forward_FlowCombination_RpcBodyRpc_2(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1210 1211 }) 1212 1213 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1214 ctx, cancel := context.WithCancel(ctx) 1215 defer cancel() 1216 if cn, ok := w.(http.CloseNotifier); ok { 1217 go func(done <-chan struct{}, closed <-chan bool) { 1218 select { 1219 case <-done: 1220 case <-closed: 1221 cancel() 1222 } 1223 }(ctx.Done(), cn.CloseNotify()) 1224 } 1225 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1226 rctx, err := runtime.AnnotateContext(ctx, req) 1227 if err != nil { 1228 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1229 } 1230 resp, md, err := request_FlowCombination_RpcBodyRpc_3(rctx, inboundMarshaler, client, req, pathParams) 1231 ctx = runtime.NewServerMetadataContext(ctx, md) 1232 if err != nil { 1233 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1234 return 1235 } 1236 1237 forward_FlowCombination_RpcBodyRpc_3(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1238 1239 }) 1240 1241 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1242 ctx, cancel := context.WithCancel(ctx) 1243 defer cancel() 1244 if cn, ok := w.(http.CloseNotifier); ok { 1245 go func(done <-chan struct{}, closed <-chan bool) { 1246 select { 1247 case <-done: 1248 case <-closed: 1249 cancel() 1250 } 1251 }(ctx.Done(), cn.CloseNotify()) 1252 } 1253 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1254 rctx, err := runtime.AnnotateContext(ctx, req) 1255 if err != nil { 1256 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1257 } 1258 resp, md, err := request_FlowCombination_RpcBodyRpc_4(rctx, inboundMarshaler, client, req, pathParams) 1259 ctx = runtime.NewServerMetadataContext(ctx, md) 1260 if err != nil { 1261 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1262 return 1263 } 1264 1265 forward_FlowCombination_RpcBodyRpc_4(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1266 1267 }) 1268 1269 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1270 ctx, cancel := context.WithCancel(ctx) 1271 defer cancel() 1272 if cn, ok := w.(http.CloseNotifier); ok { 1273 go func(done <-chan struct{}, closed <-chan bool) { 1274 select { 1275 case <-done: 1276 case <-closed: 1277 cancel() 1278 } 1279 }(ctx.Done(), cn.CloseNotify()) 1280 } 1281 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1282 rctx, err := runtime.AnnotateContext(ctx, req) 1283 if err != nil { 1284 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1285 } 1286 resp, md, err := request_FlowCombination_RpcBodyRpc_5(rctx, inboundMarshaler, client, req, pathParams) 1287 ctx = runtime.NewServerMetadataContext(ctx, md) 1288 if err != nil { 1289 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1290 return 1291 } 1292 1293 forward_FlowCombination_RpcBodyRpc_5(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1294 1295 }) 1296 1297 mux.Handle("POST", pattern_FlowCombination_RpcBodyRpc_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1298 ctx, cancel := context.WithCancel(ctx) 1299 defer cancel() 1300 if cn, ok := w.(http.CloseNotifier); ok { 1301 go func(done <-chan struct{}, closed <-chan bool) { 1302 select { 1303 case <-done: 1304 case <-closed: 1305 cancel() 1306 } 1307 }(ctx.Done(), cn.CloseNotify()) 1308 } 1309 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1310 rctx, err := runtime.AnnotateContext(ctx, req) 1311 if err != nil { 1312 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1313 } 1314 resp, md, err := request_FlowCombination_RpcBodyRpc_6(rctx, inboundMarshaler, client, req, pathParams) 1315 ctx = runtime.NewServerMetadataContext(ctx, md) 1316 if err != nil { 1317 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1318 return 1319 } 1320 1321 forward_FlowCombination_RpcBodyRpc_6(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1322 1323 }) 1324 1325 mux.Handle("POST", pattern_FlowCombination_RpcPathSingleNestedRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1326 ctx, cancel := context.WithCancel(ctx) 1327 defer cancel() 1328 if cn, ok := w.(http.CloseNotifier); ok { 1329 go func(done <-chan struct{}, closed <-chan bool) { 1330 select { 1331 case <-done: 1332 case <-closed: 1333 cancel() 1334 } 1335 }(ctx.Done(), cn.CloseNotify()) 1336 } 1337 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1338 rctx, err := runtime.AnnotateContext(ctx, req) 1339 if err != nil { 1340 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1341 } 1342 resp, md, err := request_FlowCombination_RpcPathSingleNestedRpc_0(rctx, inboundMarshaler, client, req, pathParams) 1343 ctx = runtime.NewServerMetadataContext(ctx, md) 1344 if err != nil { 1345 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1346 return 1347 } 1348 1349 forward_FlowCombination_RpcPathSingleNestedRpc_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1350 1351 }) 1352 1353 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1354 ctx, cancel := context.WithCancel(ctx) 1355 defer cancel() 1356 if cn, ok := w.(http.CloseNotifier); ok { 1357 go func(done <-chan struct{}, closed <-chan bool) { 1358 select { 1359 case <-done: 1360 case <-closed: 1361 cancel() 1362 } 1363 }(ctx.Done(), cn.CloseNotify()) 1364 } 1365 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1366 rctx, err := runtime.AnnotateContext(ctx, req) 1367 if err != nil { 1368 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1369 } 1370 resp, md, err := request_FlowCombination_RpcPathNestedRpc_0(rctx, inboundMarshaler, client, req, pathParams) 1371 ctx = runtime.NewServerMetadataContext(ctx, md) 1372 if err != nil { 1373 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1374 return 1375 } 1376 1377 forward_FlowCombination_RpcPathNestedRpc_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1378 1379 }) 1380 1381 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1382 ctx, cancel := context.WithCancel(ctx) 1383 defer cancel() 1384 if cn, ok := w.(http.CloseNotifier); ok { 1385 go func(done <-chan struct{}, closed <-chan bool) { 1386 select { 1387 case <-done: 1388 case <-closed: 1389 cancel() 1390 } 1391 }(ctx.Done(), cn.CloseNotify()) 1392 } 1393 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1394 rctx, err := runtime.AnnotateContext(ctx, req) 1395 if err != nil { 1396 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1397 } 1398 resp, md, err := request_FlowCombination_RpcPathNestedRpc_1(rctx, inboundMarshaler, client, req, pathParams) 1399 ctx = runtime.NewServerMetadataContext(ctx, md) 1400 if err != nil { 1401 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1402 return 1403 } 1404 1405 forward_FlowCombination_RpcPathNestedRpc_1(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1406 1407 }) 1408 1409 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedRpc_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1410 ctx, cancel := context.WithCancel(ctx) 1411 defer cancel() 1412 if cn, ok := w.(http.CloseNotifier); ok { 1413 go func(done <-chan struct{}, closed <-chan bool) { 1414 select { 1415 case <-done: 1416 case <-closed: 1417 cancel() 1418 } 1419 }(ctx.Done(), cn.CloseNotify()) 1420 } 1421 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1422 rctx, err := runtime.AnnotateContext(ctx, req) 1423 if err != nil { 1424 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1425 } 1426 resp, md, err := request_FlowCombination_RpcPathNestedRpc_2(rctx, inboundMarshaler, client, req, pathParams) 1427 ctx = runtime.NewServerMetadataContext(ctx, md) 1428 if err != nil { 1429 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1430 return 1431 } 1432 1433 forward_FlowCombination_RpcPathNestedRpc_2(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1434 1435 }) 1436 1437 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1438 ctx, cancel := context.WithCancel(ctx) 1439 defer cancel() 1440 if cn, ok := w.(http.CloseNotifier); ok { 1441 go func(done <-chan struct{}, closed <-chan bool) { 1442 select { 1443 case <-done: 1444 case <-closed: 1445 cancel() 1446 } 1447 }(ctx.Done(), cn.CloseNotify()) 1448 } 1449 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1450 rctx, err := runtime.AnnotateContext(ctx, req) 1451 if err != nil { 1452 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1453 } 1454 resp, md, err := request_FlowCombination_RpcBodyStream_0(rctx, inboundMarshaler, client, req, pathParams) 1455 ctx = runtime.NewServerMetadataContext(ctx, md) 1456 if err != nil { 1457 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1458 return 1459 } 1460 1461 forward_FlowCombination_RpcBodyStream_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1462 1463 }) 1464 1465 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1466 ctx, cancel := context.WithCancel(ctx) 1467 defer cancel() 1468 if cn, ok := w.(http.CloseNotifier); ok { 1469 go func(done <-chan struct{}, closed <-chan bool) { 1470 select { 1471 case <-done: 1472 case <-closed: 1473 cancel() 1474 } 1475 }(ctx.Done(), cn.CloseNotify()) 1476 } 1477 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1478 rctx, err := runtime.AnnotateContext(ctx, req) 1479 if err != nil { 1480 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1481 } 1482 resp, md, err := request_FlowCombination_RpcBodyStream_1(rctx, inboundMarshaler, client, req, pathParams) 1483 ctx = runtime.NewServerMetadataContext(ctx, md) 1484 if err != nil { 1485 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1486 return 1487 } 1488 1489 forward_FlowCombination_RpcBodyStream_1(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1490 1491 }) 1492 1493 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1494 ctx, cancel := context.WithCancel(ctx) 1495 defer cancel() 1496 if cn, ok := w.(http.CloseNotifier); ok { 1497 go func(done <-chan struct{}, closed <-chan bool) { 1498 select { 1499 case <-done: 1500 case <-closed: 1501 cancel() 1502 } 1503 }(ctx.Done(), cn.CloseNotify()) 1504 } 1505 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1506 rctx, err := runtime.AnnotateContext(ctx, req) 1507 if err != nil { 1508 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1509 } 1510 resp, md, err := request_FlowCombination_RpcBodyStream_2(rctx, inboundMarshaler, client, req, pathParams) 1511 ctx = runtime.NewServerMetadataContext(ctx, md) 1512 if err != nil { 1513 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1514 return 1515 } 1516 1517 forward_FlowCombination_RpcBodyStream_2(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1518 1519 }) 1520 1521 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1522 ctx, cancel := context.WithCancel(ctx) 1523 defer cancel() 1524 if cn, ok := w.(http.CloseNotifier); ok { 1525 go func(done <-chan struct{}, closed <-chan bool) { 1526 select { 1527 case <-done: 1528 case <-closed: 1529 cancel() 1530 } 1531 }(ctx.Done(), cn.CloseNotify()) 1532 } 1533 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1534 rctx, err := runtime.AnnotateContext(ctx, req) 1535 if err != nil { 1536 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1537 } 1538 resp, md, err := request_FlowCombination_RpcBodyStream_3(rctx, inboundMarshaler, client, req, pathParams) 1539 ctx = runtime.NewServerMetadataContext(ctx, md) 1540 if err != nil { 1541 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1542 return 1543 } 1544 1545 forward_FlowCombination_RpcBodyStream_3(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1546 1547 }) 1548 1549 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1550 ctx, cancel := context.WithCancel(ctx) 1551 defer cancel() 1552 if cn, ok := w.(http.CloseNotifier); ok { 1553 go func(done <-chan struct{}, closed <-chan bool) { 1554 select { 1555 case <-done: 1556 case <-closed: 1557 cancel() 1558 } 1559 }(ctx.Done(), cn.CloseNotify()) 1560 } 1561 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1562 rctx, err := runtime.AnnotateContext(ctx, req) 1563 if err != nil { 1564 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1565 } 1566 resp, md, err := request_FlowCombination_RpcBodyStream_4(rctx, inboundMarshaler, client, req, pathParams) 1567 ctx = runtime.NewServerMetadataContext(ctx, md) 1568 if err != nil { 1569 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1570 return 1571 } 1572 1573 forward_FlowCombination_RpcBodyStream_4(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1574 1575 }) 1576 1577 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1578 ctx, cancel := context.WithCancel(ctx) 1579 defer cancel() 1580 if cn, ok := w.(http.CloseNotifier); ok { 1581 go func(done <-chan struct{}, closed <-chan bool) { 1582 select { 1583 case <-done: 1584 case <-closed: 1585 cancel() 1586 } 1587 }(ctx.Done(), cn.CloseNotify()) 1588 } 1589 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1590 rctx, err := runtime.AnnotateContext(ctx, req) 1591 if err != nil { 1592 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1593 } 1594 resp, md, err := request_FlowCombination_RpcBodyStream_5(rctx, inboundMarshaler, client, req, pathParams) 1595 ctx = runtime.NewServerMetadataContext(ctx, md) 1596 if err != nil { 1597 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1598 return 1599 } 1600 1601 forward_FlowCombination_RpcBodyStream_5(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1602 1603 }) 1604 1605 mux.Handle("POST", pattern_FlowCombination_RpcBodyStream_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1606 ctx, cancel := context.WithCancel(ctx) 1607 defer cancel() 1608 if cn, ok := w.(http.CloseNotifier); ok { 1609 go func(done <-chan struct{}, closed <-chan bool) { 1610 select { 1611 case <-done: 1612 case <-closed: 1613 cancel() 1614 } 1615 }(ctx.Done(), cn.CloseNotify()) 1616 } 1617 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1618 rctx, err := runtime.AnnotateContext(ctx, req) 1619 if err != nil { 1620 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1621 } 1622 resp, md, err := request_FlowCombination_RpcBodyStream_6(rctx, inboundMarshaler, client, req, pathParams) 1623 ctx = runtime.NewServerMetadataContext(ctx, md) 1624 if err != nil { 1625 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1626 return 1627 } 1628 1629 forward_FlowCombination_RpcBodyStream_6(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1630 1631 }) 1632 1633 mux.Handle("POST", pattern_FlowCombination_RpcPathSingleNestedStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1634 ctx, cancel := context.WithCancel(ctx) 1635 defer cancel() 1636 if cn, ok := w.(http.CloseNotifier); ok { 1637 go func(done <-chan struct{}, closed <-chan bool) { 1638 select { 1639 case <-done: 1640 case <-closed: 1641 cancel() 1642 } 1643 }(ctx.Done(), cn.CloseNotify()) 1644 } 1645 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1646 rctx, err := runtime.AnnotateContext(ctx, req) 1647 if err != nil { 1648 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1649 } 1650 resp, md, err := request_FlowCombination_RpcPathSingleNestedStream_0(rctx, inboundMarshaler, client, req, pathParams) 1651 ctx = runtime.NewServerMetadataContext(ctx, md) 1652 if err != nil { 1653 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1654 return 1655 } 1656 1657 forward_FlowCombination_RpcPathSingleNestedStream_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1658 1659 }) 1660 1661 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1662 ctx, cancel := context.WithCancel(ctx) 1663 defer cancel() 1664 if cn, ok := w.(http.CloseNotifier); ok { 1665 go func(done <-chan struct{}, closed <-chan bool) { 1666 select { 1667 case <-done: 1668 case <-closed: 1669 cancel() 1670 } 1671 }(ctx.Done(), cn.CloseNotify()) 1672 } 1673 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1674 rctx, err := runtime.AnnotateContext(ctx, req) 1675 if err != nil { 1676 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1677 } 1678 resp, md, err := request_FlowCombination_RpcPathNestedStream_0(rctx, inboundMarshaler, client, req, pathParams) 1679 ctx = runtime.NewServerMetadataContext(ctx, md) 1680 if err != nil { 1681 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1682 return 1683 } 1684 1685 forward_FlowCombination_RpcPathNestedStream_0(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1686 1687 }) 1688 1689 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1690 ctx, cancel := context.WithCancel(ctx) 1691 defer cancel() 1692 if cn, ok := w.(http.CloseNotifier); ok { 1693 go func(done <-chan struct{}, closed <-chan bool) { 1694 select { 1695 case <-done: 1696 case <-closed: 1697 cancel() 1698 } 1699 }(ctx.Done(), cn.CloseNotify()) 1700 } 1701 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1702 rctx, err := runtime.AnnotateContext(ctx, req) 1703 if err != nil { 1704 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1705 } 1706 resp, md, err := request_FlowCombination_RpcPathNestedStream_1(rctx, inboundMarshaler, client, req, pathParams) 1707 ctx = runtime.NewServerMetadataContext(ctx, md) 1708 if err != nil { 1709 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1710 return 1711 } 1712 1713 forward_FlowCombination_RpcPathNestedStream_1(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1714 1715 }) 1716 1717 mux.Handle("POST", pattern_FlowCombination_RpcPathNestedStream_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1718 ctx, cancel := context.WithCancel(ctx) 1719 defer cancel() 1720 if cn, ok := w.(http.CloseNotifier); ok { 1721 go func(done <-chan struct{}, closed <-chan bool) { 1722 select { 1723 case <-done: 1724 case <-closed: 1725 cancel() 1726 } 1727 }(ctx.Done(), cn.CloseNotify()) 1728 } 1729 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1730 rctx, err := runtime.AnnotateContext(ctx, req) 1731 if err != nil { 1732 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1733 } 1734 resp, md, err := request_FlowCombination_RpcPathNestedStream_2(rctx, inboundMarshaler, client, req, pathParams) 1735 ctx = runtime.NewServerMetadataContext(ctx, md) 1736 if err != nil { 1737 runtime.HTTPError(ctx, outboundMarshaler, w, req, err) 1738 return 1739 } 1740 1741 forward_FlowCombination_RpcPathNestedStream_2(ctx, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 1742 1743 }) 1744 1745 return nil 1746} 1747 1748var ( 1749 pattern_FlowCombination_RpcEmptyRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"rpc", "empty"}, "")) 1750 1751 pattern_FlowCombination_RpcEmptyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"rpc", "empty", "stream"}, "")) 1752 1753 pattern_FlowCombination_StreamEmptyRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"stream", "empty", "rpc"}, "")) 1754 1755 pattern_FlowCombination_StreamEmptyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"stream", "empty"}, "")) 1756 1757 pattern_FlowCombination_RpcBodyRpc_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"rpc", "body"}, "")) 1758 1759 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"}, "")) 1760 1761 pattern_FlowCombination_RpcBodyRpc_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 0}, []string{"rpc", "query"}, "")) 1762 1763 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"}, "")) 1764 1765 pattern_FlowCombination_RpcBodyRpc_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 0}, []string{"rpc", "body", "query"}, "")) 1766 1767 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"}, "")) 1768 1769 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"}, "")) 1770 1771 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"}, "")) 1772 1773 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"}, "")) 1774 1775 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"}, "")) 1776 1777 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"}, "")) 1778 1779 pattern_FlowCombination_RpcBodyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"rpc", "body", "stream"}, "")) 1780 1781 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"}, "")) 1782 1783 pattern_FlowCombination_RpcBodyStream_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"rpc", "query", "stream"}, "")) 1784 1785 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"}, "")) 1786 1787 pattern_FlowCombination_RpcBodyStream_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"rpc", "body", "query", "stream"}, "")) 1788 1789 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"}, "")) 1790 1791 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"}, "")) 1792 1793 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"}, "")) 1794 1795 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"}, "")) 1796 1797 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"}, "")) 1798 1799 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"}, "")) 1800) 1801 1802var ( 1803 forward_FlowCombination_RpcEmptyRpc_0 = runtime.ForwardResponseMessage 1804 1805 forward_FlowCombination_RpcEmptyStream_0 = runtime.ForwardResponseStream 1806 1807 forward_FlowCombination_StreamEmptyRpc_0 = runtime.ForwardResponseMessage 1808 1809 forward_FlowCombination_StreamEmptyStream_0 = runtime.ForwardResponseStream 1810 1811 forward_FlowCombination_RpcBodyRpc_0 = runtime.ForwardResponseMessage 1812 1813 forward_FlowCombination_RpcBodyRpc_1 = runtime.ForwardResponseMessage 1814 1815 forward_FlowCombination_RpcBodyRpc_2 = runtime.ForwardResponseMessage 1816 1817 forward_FlowCombination_RpcBodyRpc_3 = runtime.ForwardResponseMessage 1818 1819 forward_FlowCombination_RpcBodyRpc_4 = runtime.ForwardResponseMessage 1820 1821 forward_FlowCombination_RpcBodyRpc_5 = runtime.ForwardResponseMessage 1822 1823 forward_FlowCombination_RpcBodyRpc_6 = runtime.ForwardResponseMessage 1824 1825 forward_FlowCombination_RpcPathSingleNestedRpc_0 = runtime.ForwardResponseMessage 1826 1827 forward_FlowCombination_RpcPathNestedRpc_0 = runtime.ForwardResponseMessage 1828 1829 forward_FlowCombination_RpcPathNestedRpc_1 = runtime.ForwardResponseMessage 1830 1831 forward_FlowCombination_RpcPathNestedRpc_2 = runtime.ForwardResponseMessage 1832 1833 forward_FlowCombination_RpcBodyStream_0 = runtime.ForwardResponseStream 1834 1835 forward_FlowCombination_RpcBodyStream_1 = runtime.ForwardResponseStream 1836 1837 forward_FlowCombination_RpcBodyStream_2 = runtime.ForwardResponseStream 1838 1839 forward_FlowCombination_RpcBodyStream_3 = runtime.ForwardResponseStream 1840 1841 forward_FlowCombination_RpcBodyStream_4 = runtime.ForwardResponseStream 1842 1843 forward_FlowCombination_RpcBodyStream_5 = runtime.ForwardResponseStream 1844 1845 forward_FlowCombination_RpcBodyStream_6 = runtime.ForwardResponseStream 1846 1847 forward_FlowCombination_RpcPathSingleNestedStream_0 = runtime.ForwardResponseStream 1848 1849 forward_FlowCombination_RpcPathNestedStream_0 = runtime.ForwardResponseStream 1850 1851 forward_FlowCombination_RpcPathNestedStream_1 = runtime.ForwardResponseStream 1852 1853 forward_FlowCombination_RpcPathNestedStream_2 = runtime.ForwardResponseStream 1854) 1855