Source file src/github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/examplepb/flow_combination.pb.gw.go

Documentation: github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/examplepb

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

View as plain text