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