...

Source file src/github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/helloworld/helloworld.pb.gw.go

Documentation: github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/helloworld

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: examples/internal/helloworld/helloworld.proto
     3  
     4  /*
     5  Package helloworld is a reverse proxy.
     6  
     7  It translates gRPC into RESTful JSON APIs.
     8  */
     9  package helloworld
    10  
    11  import (
    12  	"context"
    13  	"io"
    14  	"net/http"
    15  
    16  	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    17  	"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
    18  	"google.golang.org/grpc"
    19  	"google.golang.org/grpc/codes"
    20  	"google.golang.org/grpc/grpclog"
    21  	"google.golang.org/grpc/metadata"
    22  	"google.golang.org/grpc/status"
    23  	"google.golang.org/protobuf/proto"
    24  )
    25  
    26  // Suppress "imported and not used" errors
    27  var _ codes.Code
    28  var _ io.Reader
    29  var _ status.Status
    30  var _ = runtime.String
    31  var _ = utilities.NewDoubleArray
    32  var _ = metadata.Join
    33  
    34  var (
    35  	filter_Greeter_SayHello_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
    36  )
    37  
    38  func request_Greeter_SayHello_0(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    39  	var protoReq HelloRequest
    40  	var metadata runtime.ServerMetadata
    41  
    42  	var (
    43  		val string
    44  		ok  bool
    45  		err error
    46  		_   = err
    47  	)
    48  
    49  	val, ok = pathParams["name"]
    50  	if !ok {
    51  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
    52  	}
    53  
    54  	protoReq.Name, err = runtime.String(val)
    55  	if err != nil {
    56  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
    57  	}
    58  
    59  	if err := req.ParseForm(); err != nil {
    60  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    61  	}
    62  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_0); err != nil {
    63  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    64  	}
    65  
    66  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    67  	return msg, metadata, err
    68  
    69  }
    70  
    71  func local_request_Greeter_SayHello_0(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    72  	var protoReq HelloRequest
    73  	var metadata runtime.ServerMetadata
    74  
    75  	var (
    76  		val string
    77  		ok  bool
    78  		err error
    79  		_   = err
    80  	)
    81  
    82  	val, ok = pathParams["name"]
    83  	if !ok {
    84  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
    85  	}
    86  
    87  	protoReq.Name, err = runtime.String(val)
    88  	if err != nil {
    89  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)
    90  	}
    91  
    92  	if err := req.ParseForm(); err != nil {
    93  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    94  	}
    95  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_0); err != nil {
    96  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    97  	}
    98  
    99  	msg, err := server.SayHello(ctx, &protoReq)
   100  	return msg, metadata, err
   101  
   102  }
   103  
   104  var (
   105  	filter_Greeter_SayHello_1 = &utilities.DoubleArray{Encoding: map[string]int{"strVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   106  )
   107  
   108  func request_Greeter_SayHello_1(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   109  	var protoReq HelloRequest
   110  	var metadata runtime.ServerMetadata
   111  
   112  	var (
   113  		val string
   114  		ok  bool
   115  		err error
   116  		_   = err
   117  	)
   118  
   119  	val, ok = pathParams["strVal"]
   120  	if !ok {
   121  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "strVal")
   122  	}
   123  
   124  	protoReq.StrVal, err = runtime.StringValue(val)
   125  	if err != nil {
   126  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "strVal", err)
   127  	}
   128  
   129  	if err := req.ParseForm(); err != nil {
   130  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   131  	}
   132  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_1); err != nil {
   133  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   134  	}
   135  
   136  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   137  	return msg, metadata, err
   138  
   139  }
   140  
   141  func local_request_Greeter_SayHello_1(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   142  	var protoReq HelloRequest
   143  	var metadata runtime.ServerMetadata
   144  
   145  	var (
   146  		val string
   147  		ok  bool
   148  		err error
   149  		_   = err
   150  	)
   151  
   152  	val, ok = pathParams["strVal"]
   153  	if !ok {
   154  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "strVal")
   155  	}
   156  
   157  	protoReq.StrVal, err = runtime.StringValue(val)
   158  	if err != nil {
   159  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "strVal", err)
   160  	}
   161  
   162  	if err := req.ParseForm(); err != nil {
   163  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   164  	}
   165  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_1); err != nil {
   166  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   167  	}
   168  
   169  	msg, err := server.SayHello(ctx, &protoReq)
   170  	return msg, metadata, err
   171  
   172  }
   173  
   174  var (
   175  	filter_Greeter_SayHello_2 = &utilities.DoubleArray{Encoding: map[string]int{"floatVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   176  )
   177  
   178  func request_Greeter_SayHello_2(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   179  	var protoReq HelloRequest
   180  	var metadata runtime.ServerMetadata
   181  
   182  	var (
   183  		val string
   184  		ok  bool
   185  		err error
   186  		_   = err
   187  	)
   188  
   189  	val, ok = pathParams["floatVal"]
   190  	if !ok {
   191  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "floatVal")
   192  	}
   193  
   194  	protoReq.FloatVal, err = runtime.FloatValue(val)
   195  	if err != nil {
   196  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "floatVal", err)
   197  	}
   198  
   199  	if err := req.ParseForm(); err != nil {
   200  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   201  	}
   202  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_2); err != nil {
   203  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   204  	}
   205  
   206  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   207  	return msg, metadata, err
   208  
   209  }
   210  
   211  func local_request_Greeter_SayHello_2(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   212  	var protoReq HelloRequest
   213  	var metadata runtime.ServerMetadata
   214  
   215  	var (
   216  		val string
   217  		ok  bool
   218  		err error
   219  		_   = err
   220  	)
   221  
   222  	val, ok = pathParams["floatVal"]
   223  	if !ok {
   224  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "floatVal")
   225  	}
   226  
   227  	protoReq.FloatVal, err = runtime.FloatValue(val)
   228  	if err != nil {
   229  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "floatVal", err)
   230  	}
   231  
   232  	if err := req.ParseForm(); err != nil {
   233  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   234  	}
   235  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_2); err != nil {
   236  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   237  	}
   238  
   239  	msg, err := server.SayHello(ctx, &protoReq)
   240  	return msg, metadata, err
   241  
   242  }
   243  
   244  var (
   245  	filter_Greeter_SayHello_3 = &utilities.DoubleArray{Encoding: map[string]int{"doubleVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   246  )
   247  
   248  func request_Greeter_SayHello_3(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   249  	var protoReq HelloRequest
   250  	var metadata runtime.ServerMetadata
   251  
   252  	var (
   253  		val string
   254  		ok  bool
   255  		err error
   256  		_   = err
   257  	)
   258  
   259  	val, ok = pathParams["doubleVal"]
   260  	if !ok {
   261  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "doubleVal")
   262  	}
   263  
   264  	protoReq.DoubleVal, err = runtime.DoubleValue(val)
   265  	if err != nil {
   266  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "doubleVal", err)
   267  	}
   268  
   269  	if err := req.ParseForm(); err != nil {
   270  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   271  	}
   272  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_3); err != nil {
   273  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   274  	}
   275  
   276  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   277  	return msg, metadata, err
   278  
   279  }
   280  
   281  func local_request_Greeter_SayHello_3(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   282  	var protoReq HelloRequest
   283  	var metadata runtime.ServerMetadata
   284  
   285  	var (
   286  		val string
   287  		ok  bool
   288  		err error
   289  		_   = err
   290  	)
   291  
   292  	val, ok = pathParams["doubleVal"]
   293  	if !ok {
   294  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "doubleVal")
   295  	}
   296  
   297  	protoReq.DoubleVal, err = runtime.DoubleValue(val)
   298  	if err != nil {
   299  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "doubleVal", err)
   300  	}
   301  
   302  	if err := req.ParseForm(); err != nil {
   303  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   304  	}
   305  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_3); err != nil {
   306  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   307  	}
   308  
   309  	msg, err := server.SayHello(ctx, &protoReq)
   310  	return msg, metadata, err
   311  
   312  }
   313  
   314  var (
   315  	filter_Greeter_SayHello_4 = &utilities.DoubleArray{Encoding: map[string]int{"boolVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   316  )
   317  
   318  func request_Greeter_SayHello_4(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   319  	var protoReq HelloRequest
   320  	var metadata runtime.ServerMetadata
   321  
   322  	var (
   323  		val string
   324  		ok  bool
   325  		err error
   326  		_   = err
   327  	)
   328  
   329  	val, ok = pathParams["boolVal"]
   330  	if !ok {
   331  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "boolVal")
   332  	}
   333  
   334  	protoReq.BoolVal, err = runtime.BoolValue(val)
   335  	if err != nil {
   336  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "boolVal", err)
   337  	}
   338  
   339  	if err := req.ParseForm(); err != nil {
   340  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   341  	}
   342  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_4); err != nil {
   343  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   344  	}
   345  
   346  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   347  	return msg, metadata, err
   348  
   349  }
   350  
   351  func local_request_Greeter_SayHello_4(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   352  	var protoReq HelloRequest
   353  	var metadata runtime.ServerMetadata
   354  
   355  	var (
   356  		val string
   357  		ok  bool
   358  		err error
   359  		_   = err
   360  	)
   361  
   362  	val, ok = pathParams["boolVal"]
   363  	if !ok {
   364  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "boolVal")
   365  	}
   366  
   367  	protoReq.BoolVal, err = runtime.BoolValue(val)
   368  	if err != nil {
   369  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "boolVal", err)
   370  	}
   371  
   372  	if err := req.ParseForm(); err != nil {
   373  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   374  	}
   375  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_4); err != nil {
   376  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   377  	}
   378  
   379  	msg, err := server.SayHello(ctx, &protoReq)
   380  	return msg, metadata, err
   381  
   382  }
   383  
   384  var (
   385  	filter_Greeter_SayHello_5 = &utilities.DoubleArray{Encoding: map[string]int{"bytesVal": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   386  )
   387  
   388  func request_Greeter_SayHello_5(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   389  	var protoReq HelloRequest
   390  	var metadata runtime.ServerMetadata
   391  
   392  	var (
   393  		val string
   394  		ok  bool
   395  		err error
   396  		_   = err
   397  	)
   398  
   399  	val, ok = pathParams["bytesVal"]
   400  	if !ok {
   401  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bytesVal")
   402  	}
   403  
   404  	protoReq.BytesVal, err = runtime.BytesValue(val)
   405  	if err != nil {
   406  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bytesVal", err)
   407  	}
   408  
   409  	if err := req.ParseForm(); err != nil {
   410  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   411  	}
   412  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_5); err != nil {
   413  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   414  	}
   415  
   416  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   417  	return msg, metadata, err
   418  
   419  }
   420  
   421  func local_request_Greeter_SayHello_5(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   422  	var protoReq HelloRequest
   423  	var metadata runtime.ServerMetadata
   424  
   425  	var (
   426  		val string
   427  		ok  bool
   428  		err error
   429  		_   = err
   430  	)
   431  
   432  	val, ok = pathParams["bytesVal"]
   433  	if !ok {
   434  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bytesVal")
   435  	}
   436  
   437  	protoReq.BytesVal, err = runtime.BytesValue(val)
   438  	if err != nil {
   439  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bytesVal", err)
   440  	}
   441  
   442  	if err := req.ParseForm(); err != nil {
   443  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   444  	}
   445  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_5); err != nil {
   446  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   447  	}
   448  
   449  	msg, err := server.SayHello(ctx, &protoReq)
   450  	return msg, metadata, err
   451  
   452  }
   453  
   454  var (
   455  	filter_Greeter_SayHello_6 = &utilities.DoubleArray{Encoding: map[string]int{"int32Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   456  )
   457  
   458  func request_Greeter_SayHello_6(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   459  	var protoReq HelloRequest
   460  	var metadata runtime.ServerMetadata
   461  
   462  	var (
   463  		val string
   464  		ok  bool
   465  		err error
   466  		_   = err
   467  	)
   468  
   469  	val, ok = pathParams["int32Val"]
   470  	if !ok {
   471  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32Val")
   472  	}
   473  
   474  	protoReq.Int32Val, err = runtime.Int32Value(val)
   475  	if err != nil {
   476  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32Val", err)
   477  	}
   478  
   479  	if err := req.ParseForm(); err != nil {
   480  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   481  	}
   482  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_6); err != nil {
   483  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   484  	}
   485  
   486  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   487  	return msg, metadata, err
   488  
   489  }
   490  
   491  func local_request_Greeter_SayHello_6(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   492  	var protoReq HelloRequest
   493  	var metadata runtime.ServerMetadata
   494  
   495  	var (
   496  		val string
   497  		ok  bool
   498  		err error
   499  		_   = err
   500  	)
   501  
   502  	val, ok = pathParams["int32Val"]
   503  	if !ok {
   504  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32Val")
   505  	}
   506  
   507  	protoReq.Int32Val, err = runtime.Int32Value(val)
   508  	if err != nil {
   509  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32Val", err)
   510  	}
   511  
   512  	if err := req.ParseForm(); err != nil {
   513  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   514  	}
   515  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_6); err != nil {
   516  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   517  	}
   518  
   519  	msg, err := server.SayHello(ctx, &protoReq)
   520  	return msg, metadata, err
   521  
   522  }
   523  
   524  var (
   525  	filter_Greeter_SayHello_7 = &utilities.DoubleArray{Encoding: map[string]int{"uint32Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   526  )
   527  
   528  func request_Greeter_SayHello_7(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   529  	var protoReq HelloRequest
   530  	var metadata runtime.ServerMetadata
   531  
   532  	var (
   533  		val string
   534  		ok  bool
   535  		err error
   536  		_   = err
   537  	)
   538  
   539  	val, ok = pathParams["uint32Val"]
   540  	if !ok {
   541  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32Val")
   542  	}
   543  
   544  	protoReq.Uint32Val, err = runtime.UInt32Value(val)
   545  	if err != nil {
   546  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32Val", err)
   547  	}
   548  
   549  	if err := req.ParseForm(); err != nil {
   550  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   551  	}
   552  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_7); err != nil {
   553  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   554  	}
   555  
   556  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   557  	return msg, metadata, err
   558  
   559  }
   560  
   561  func local_request_Greeter_SayHello_7(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   562  	var protoReq HelloRequest
   563  	var metadata runtime.ServerMetadata
   564  
   565  	var (
   566  		val string
   567  		ok  bool
   568  		err error
   569  		_   = err
   570  	)
   571  
   572  	val, ok = pathParams["uint32Val"]
   573  	if !ok {
   574  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32Val")
   575  	}
   576  
   577  	protoReq.Uint32Val, err = runtime.UInt32Value(val)
   578  	if err != nil {
   579  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32Val", err)
   580  	}
   581  
   582  	if err := req.ParseForm(); err != nil {
   583  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   584  	}
   585  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_7); err != nil {
   586  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   587  	}
   588  
   589  	msg, err := server.SayHello(ctx, &protoReq)
   590  	return msg, metadata, err
   591  
   592  }
   593  
   594  var (
   595  	filter_Greeter_SayHello_8 = &utilities.DoubleArray{Encoding: map[string]int{"int64Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   596  )
   597  
   598  func request_Greeter_SayHello_8(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   599  	var protoReq HelloRequest
   600  	var metadata runtime.ServerMetadata
   601  
   602  	var (
   603  		val string
   604  		ok  bool
   605  		err error
   606  		_   = err
   607  	)
   608  
   609  	val, ok = pathParams["int64Val"]
   610  	if !ok {
   611  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64Val")
   612  	}
   613  
   614  	protoReq.Int64Val, err = runtime.Int64Value(val)
   615  	if err != nil {
   616  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64Val", err)
   617  	}
   618  
   619  	if err := req.ParseForm(); err != nil {
   620  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   621  	}
   622  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_8); err != nil {
   623  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   624  	}
   625  
   626  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   627  	return msg, metadata, err
   628  
   629  }
   630  
   631  func local_request_Greeter_SayHello_8(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   632  	var protoReq HelloRequest
   633  	var metadata runtime.ServerMetadata
   634  
   635  	var (
   636  		val string
   637  		ok  bool
   638  		err error
   639  		_   = err
   640  	)
   641  
   642  	val, ok = pathParams["int64Val"]
   643  	if !ok {
   644  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64Val")
   645  	}
   646  
   647  	protoReq.Int64Val, err = runtime.Int64Value(val)
   648  	if err != nil {
   649  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64Val", err)
   650  	}
   651  
   652  	if err := req.ParseForm(); err != nil {
   653  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   654  	}
   655  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_8); err != nil {
   656  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   657  	}
   658  
   659  	msg, err := server.SayHello(ctx, &protoReq)
   660  	return msg, metadata, err
   661  
   662  }
   663  
   664  var (
   665  	filter_Greeter_SayHello_9 = &utilities.DoubleArray{Encoding: map[string]int{"uint64Val": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   666  )
   667  
   668  func request_Greeter_SayHello_9(ctx context.Context, marshaler runtime.Marshaler, client GreeterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   669  	var protoReq HelloRequest
   670  	var metadata runtime.ServerMetadata
   671  
   672  	var (
   673  		val string
   674  		ok  bool
   675  		err error
   676  		_   = err
   677  	)
   678  
   679  	val, ok = pathParams["uint64Val"]
   680  	if !ok {
   681  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64Val")
   682  	}
   683  
   684  	protoReq.Uint64Val, err = runtime.UInt64Value(val)
   685  	if err != nil {
   686  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64Val", err)
   687  	}
   688  
   689  	if err := req.ParseForm(); err != nil {
   690  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   691  	}
   692  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_9); err != nil {
   693  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   694  	}
   695  
   696  	msg, err := client.SayHello(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   697  	return msg, metadata, err
   698  
   699  }
   700  
   701  func local_request_Greeter_SayHello_9(ctx context.Context, marshaler runtime.Marshaler, server GreeterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   702  	var protoReq HelloRequest
   703  	var metadata runtime.ServerMetadata
   704  
   705  	var (
   706  		val string
   707  		ok  bool
   708  		err error
   709  		_   = err
   710  	)
   711  
   712  	val, ok = pathParams["uint64Val"]
   713  	if !ok {
   714  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64Val")
   715  	}
   716  
   717  	protoReq.Uint64Val, err = runtime.UInt64Value(val)
   718  	if err != nil {
   719  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64Val", err)
   720  	}
   721  
   722  	if err := req.ParseForm(); err != nil {
   723  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   724  	}
   725  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Greeter_SayHello_9); err != nil {
   726  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   727  	}
   728  
   729  	msg, err := server.SayHello(ctx, &protoReq)
   730  	return msg, metadata, err
   731  
   732  }
   733  
   734  // RegisterGreeterHandlerServer registers the http handlers for service Greeter to "mux".
   735  // UnaryRPC     :call GreeterServer directly.
   736  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   737  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterGreeterHandlerFromEndpoint instead.
   738  func RegisterGreeterHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GreeterServer) error {
   739  
   740  	mux.Handle("GET", pattern_Greeter_SayHello_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   741  		ctx, cancel := context.WithCancel(req.Context())
   742  		defer cancel()
   743  		var stream runtime.ServerTransportStream
   744  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   745  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   746  		var err error
   747  		var annotatedContext context.Context
   748  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/{name}"))
   749  		if err != nil {
   750  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   751  			return
   752  		}
   753  		resp, md, err := local_request_Greeter_SayHello_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   754  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   755  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   756  		if err != nil {
   757  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   758  			return
   759  		}
   760  
   761  		forward_Greeter_SayHello_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   762  
   763  	})
   764  
   765  	mux.Handle("GET", pattern_Greeter_SayHello_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   766  		ctx, cancel := context.WithCancel(req.Context())
   767  		defer cancel()
   768  		var stream runtime.ServerTransportStream
   769  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   770  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   771  		var err error
   772  		var annotatedContext context.Context
   773  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/strval/{strVal}"))
   774  		if err != nil {
   775  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   776  			return
   777  		}
   778  		resp, md, err := local_request_Greeter_SayHello_1(annotatedContext, inboundMarshaler, server, req, pathParams)
   779  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   780  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   781  		if err != nil {
   782  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   783  			return
   784  		}
   785  
   786  		forward_Greeter_SayHello_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   787  
   788  	})
   789  
   790  	mux.Handle("GET", pattern_Greeter_SayHello_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   791  		ctx, cancel := context.WithCancel(req.Context())
   792  		defer cancel()
   793  		var stream runtime.ServerTransportStream
   794  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   795  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   796  		var err error
   797  		var annotatedContext context.Context
   798  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/floatval/{floatVal}"))
   799  		if err != nil {
   800  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   801  			return
   802  		}
   803  		resp, md, err := local_request_Greeter_SayHello_2(annotatedContext, inboundMarshaler, server, req, pathParams)
   804  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   805  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   806  		if err != nil {
   807  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   808  			return
   809  		}
   810  
   811  		forward_Greeter_SayHello_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   812  
   813  	})
   814  
   815  	mux.Handle("GET", pattern_Greeter_SayHello_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   816  		ctx, cancel := context.WithCancel(req.Context())
   817  		defer cancel()
   818  		var stream runtime.ServerTransportStream
   819  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   820  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   821  		var err error
   822  		var annotatedContext context.Context
   823  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/doubleval/{doubleVal}"))
   824  		if err != nil {
   825  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   826  			return
   827  		}
   828  		resp, md, err := local_request_Greeter_SayHello_3(annotatedContext, inboundMarshaler, server, req, pathParams)
   829  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   830  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   831  		if err != nil {
   832  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   833  			return
   834  		}
   835  
   836  		forward_Greeter_SayHello_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   837  
   838  	})
   839  
   840  	mux.Handle("GET", pattern_Greeter_SayHello_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   841  		ctx, cancel := context.WithCancel(req.Context())
   842  		defer cancel()
   843  		var stream runtime.ServerTransportStream
   844  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   845  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   846  		var err error
   847  		var annotatedContext context.Context
   848  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/boolval/{boolVal}"))
   849  		if err != nil {
   850  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   851  			return
   852  		}
   853  		resp, md, err := local_request_Greeter_SayHello_4(annotatedContext, inboundMarshaler, server, req, pathParams)
   854  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   855  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   856  		if err != nil {
   857  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   858  			return
   859  		}
   860  
   861  		forward_Greeter_SayHello_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   862  
   863  	})
   864  
   865  	mux.Handle("GET", pattern_Greeter_SayHello_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   866  		ctx, cancel := context.WithCancel(req.Context())
   867  		defer cancel()
   868  		var stream runtime.ServerTransportStream
   869  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   870  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   871  		var err error
   872  		var annotatedContext context.Context
   873  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/bytesval/{bytesVal}"))
   874  		if err != nil {
   875  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   876  			return
   877  		}
   878  		resp, md, err := local_request_Greeter_SayHello_5(annotatedContext, inboundMarshaler, server, req, pathParams)
   879  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   880  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   881  		if err != nil {
   882  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   883  			return
   884  		}
   885  
   886  		forward_Greeter_SayHello_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   887  
   888  	})
   889  
   890  	mux.Handle("GET", pattern_Greeter_SayHello_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   891  		ctx, cancel := context.WithCancel(req.Context())
   892  		defer cancel()
   893  		var stream runtime.ServerTransportStream
   894  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   895  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   896  		var err error
   897  		var annotatedContext context.Context
   898  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int32val/{int32Val}"))
   899  		if err != nil {
   900  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   901  			return
   902  		}
   903  		resp, md, err := local_request_Greeter_SayHello_6(annotatedContext, inboundMarshaler, server, req, pathParams)
   904  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   905  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   906  		if err != nil {
   907  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   908  			return
   909  		}
   910  
   911  		forward_Greeter_SayHello_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   912  
   913  	})
   914  
   915  	mux.Handle("GET", pattern_Greeter_SayHello_7, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   916  		ctx, cancel := context.WithCancel(req.Context())
   917  		defer cancel()
   918  		var stream runtime.ServerTransportStream
   919  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   920  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   921  		var err error
   922  		var annotatedContext context.Context
   923  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint32val/{uint32Val}"))
   924  		if err != nil {
   925  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   926  			return
   927  		}
   928  		resp, md, err := local_request_Greeter_SayHello_7(annotatedContext, inboundMarshaler, server, req, pathParams)
   929  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   930  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   931  		if err != nil {
   932  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   933  			return
   934  		}
   935  
   936  		forward_Greeter_SayHello_7(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   937  
   938  	})
   939  
   940  	mux.Handle("GET", pattern_Greeter_SayHello_8, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   941  		ctx, cancel := context.WithCancel(req.Context())
   942  		defer cancel()
   943  		var stream runtime.ServerTransportStream
   944  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   945  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   946  		var err error
   947  		var annotatedContext context.Context
   948  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int64val/{int64Val}"))
   949  		if err != nil {
   950  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   951  			return
   952  		}
   953  		resp, md, err := local_request_Greeter_SayHello_8(annotatedContext, inboundMarshaler, server, req, pathParams)
   954  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   955  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   956  		if err != nil {
   957  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   958  			return
   959  		}
   960  
   961  		forward_Greeter_SayHello_8(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   962  
   963  	})
   964  
   965  	mux.Handle("GET", pattern_Greeter_SayHello_9, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   966  		ctx, cancel := context.WithCancel(req.Context())
   967  		defer cancel()
   968  		var stream runtime.ServerTransportStream
   969  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   970  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   971  		var err error
   972  		var annotatedContext context.Context
   973  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint64val/{uint64Val}"))
   974  		if err != nil {
   975  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   976  			return
   977  		}
   978  		resp, md, err := local_request_Greeter_SayHello_9(annotatedContext, inboundMarshaler, server, req, pathParams)
   979  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   980  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   981  		if err != nil {
   982  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   983  			return
   984  		}
   985  
   986  		forward_Greeter_SayHello_9(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   987  
   988  	})
   989  
   990  	return nil
   991  }
   992  
   993  // RegisterGreeterHandlerFromEndpoint is same as RegisterGreeterHandler but
   994  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   995  func RegisterGreeterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   996  	conn, err := grpc.DialContext(ctx, endpoint, opts...)
   997  	if err != nil {
   998  		return err
   999  	}
  1000  	defer func() {
  1001  		if err != nil {
  1002  			if cerr := conn.Close(); cerr != nil {
  1003  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  1004  			}
  1005  			return
  1006  		}
  1007  		go func() {
  1008  			<-ctx.Done()
  1009  			if cerr := conn.Close(); cerr != nil {
  1010  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  1011  			}
  1012  		}()
  1013  	}()
  1014  
  1015  	return RegisterGreeterHandler(ctx, mux, conn)
  1016  }
  1017  
  1018  // RegisterGreeterHandler registers the http handlers for service Greeter to "mux".
  1019  // The handlers forward requests to the grpc endpoint over "conn".
  1020  func RegisterGreeterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  1021  	return RegisterGreeterHandlerClient(ctx, mux, NewGreeterClient(conn))
  1022  }
  1023  
  1024  // RegisterGreeterHandlerClient registers the http handlers for service Greeter
  1025  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "GreeterClient".
  1026  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "GreeterClient"
  1027  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  1028  // "GreeterClient" to call the correct interceptors.
  1029  func RegisterGreeterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GreeterClient) error {
  1030  
  1031  	mux.Handle("GET", pattern_Greeter_SayHello_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1032  		ctx, cancel := context.WithCancel(req.Context())
  1033  		defer cancel()
  1034  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1035  		var err error
  1036  		var annotatedContext context.Context
  1037  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/{name}"))
  1038  		if err != nil {
  1039  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1040  			return
  1041  		}
  1042  		resp, md, err := request_Greeter_SayHello_0(annotatedContext, inboundMarshaler, client, req, pathParams)
  1043  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1044  		if err != nil {
  1045  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1046  			return
  1047  		}
  1048  
  1049  		forward_Greeter_SayHello_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1050  
  1051  	})
  1052  
  1053  	mux.Handle("GET", pattern_Greeter_SayHello_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1054  		ctx, cancel := context.WithCancel(req.Context())
  1055  		defer cancel()
  1056  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1057  		var err error
  1058  		var annotatedContext context.Context
  1059  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/strval/{strVal}"))
  1060  		if err != nil {
  1061  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1062  			return
  1063  		}
  1064  		resp, md, err := request_Greeter_SayHello_1(annotatedContext, inboundMarshaler, client, req, pathParams)
  1065  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1066  		if err != nil {
  1067  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1068  			return
  1069  		}
  1070  
  1071  		forward_Greeter_SayHello_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1072  
  1073  	})
  1074  
  1075  	mux.Handle("GET", pattern_Greeter_SayHello_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1076  		ctx, cancel := context.WithCancel(req.Context())
  1077  		defer cancel()
  1078  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1079  		var err error
  1080  		var annotatedContext context.Context
  1081  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/floatval/{floatVal}"))
  1082  		if err != nil {
  1083  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1084  			return
  1085  		}
  1086  		resp, md, err := request_Greeter_SayHello_2(annotatedContext, inboundMarshaler, client, req, pathParams)
  1087  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1088  		if err != nil {
  1089  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1090  			return
  1091  		}
  1092  
  1093  		forward_Greeter_SayHello_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1094  
  1095  	})
  1096  
  1097  	mux.Handle("GET", pattern_Greeter_SayHello_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1098  		ctx, cancel := context.WithCancel(req.Context())
  1099  		defer cancel()
  1100  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1101  		var err error
  1102  		var annotatedContext context.Context
  1103  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/doubleval/{doubleVal}"))
  1104  		if err != nil {
  1105  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1106  			return
  1107  		}
  1108  		resp, md, err := request_Greeter_SayHello_3(annotatedContext, inboundMarshaler, client, req, pathParams)
  1109  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1110  		if err != nil {
  1111  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1112  			return
  1113  		}
  1114  
  1115  		forward_Greeter_SayHello_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1116  
  1117  	})
  1118  
  1119  	mux.Handle("GET", pattern_Greeter_SayHello_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1120  		ctx, cancel := context.WithCancel(req.Context())
  1121  		defer cancel()
  1122  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1123  		var err error
  1124  		var annotatedContext context.Context
  1125  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/boolval/{boolVal}"))
  1126  		if err != nil {
  1127  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1128  			return
  1129  		}
  1130  		resp, md, err := request_Greeter_SayHello_4(annotatedContext, inboundMarshaler, client, req, pathParams)
  1131  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1132  		if err != nil {
  1133  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1134  			return
  1135  		}
  1136  
  1137  		forward_Greeter_SayHello_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1138  
  1139  	})
  1140  
  1141  	mux.Handle("GET", pattern_Greeter_SayHello_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1142  		ctx, cancel := context.WithCancel(req.Context())
  1143  		defer cancel()
  1144  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1145  		var err error
  1146  		var annotatedContext context.Context
  1147  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/bytesval/{bytesVal}"))
  1148  		if err != nil {
  1149  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1150  			return
  1151  		}
  1152  		resp, md, err := request_Greeter_SayHello_5(annotatedContext, inboundMarshaler, client, req, pathParams)
  1153  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1154  		if err != nil {
  1155  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1156  			return
  1157  		}
  1158  
  1159  		forward_Greeter_SayHello_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1160  
  1161  	})
  1162  
  1163  	mux.Handle("GET", pattern_Greeter_SayHello_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1164  		ctx, cancel := context.WithCancel(req.Context())
  1165  		defer cancel()
  1166  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1167  		var err error
  1168  		var annotatedContext context.Context
  1169  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int32val/{int32Val}"))
  1170  		if err != nil {
  1171  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1172  			return
  1173  		}
  1174  		resp, md, err := request_Greeter_SayHello_6(annotatedContext, inboundMarshaler, client, req, pathParams)
  1175  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1176  		if err != nil {
  1177  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1178  			return
  1179  		}
  1180  
  1181  		forward_Greeter_SayHello_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1182  
  1183  	})
  1184  
  1185  	mux.Handle("GET", pattern_Greeter_SayHello_7, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1186  		ctx, cancel := context.WithCancel(req.Context())
  1187  		defer cancel()
  1188  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1189  		var err error
  1190  		var annotatedContext context.Context
  1191  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint32val/{uint32Val}"))
  1192  		if err != nil {
  1193  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1194  			return
  1195  		}
  1196  		resp, md, err := request_Greeter_SayHello_7(annotatedContext, inboundMarshaler, client, req, pathParams)
  1197  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1198  		if err != nil {
  1199  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1200  			return
  1201  		}
  1202  
  1203  		forward_Greeter_SayHello_7(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1204  
  1205  	})
  1206  
  1207  	mux.Handle("GET", pattern_Greeter_SayHello_8, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1208  		ctx, cancel := context.WithCancel(req.Context())
  1209  		defer cancel()
  1210  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1211  		var err error
  1212  		var annotatedContext context.Context
  1213  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/int64val/{int64Val}"))
  1214  		if err != nil {
  1215  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1216  			return
  1217  		}
  1218  		resp, md, err := request_Greeter_SayHello_8(annotatedContext, inboundMarshaler, client, req, pathParams)
  1219  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1220  		if err != nil {
  1221  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1222  			return
  1223  		}
  1224  
  1225  		forward_Greeter_SayHello_8(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1226  
  1227  	})
  1228  
  1229  	mux.Handle("GET", pattern_Greeter_SayHello_9, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1230  		ctx, cancel := context.WithCancel(req.Context())
  1231  		defer cancel()
  1232  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1233  		var err error
  1234  		var annotatedContext context.Context
  1235  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.helloworld.Greeter/SayHello", runtime.WithHTTPPathPattern("/say/uint64val/{uint64Val}"))
  1236  		if err != nil {
  1237  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1238  			return
  1239  		}
  1240  		resp, md, err := request_Greeter_SayHello_9(annotatedContext, inboundMarshaler, client, req, pathParams)
  1241  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1242  		if err != nil {
  1243  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1244  			return
  1245  		}
  1246  
  1247  		forward_Greeter_SayHello_9(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1248  
  1249  	})
  1250  
  1251  	return nil
  1252  }
  1253  
  1254  var (
  1255  	pattern_Greeter_SayHello_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"say", "name"}, ""))
  1256  
  1257  	pattern_Greeter_SayHello_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "strval", "strVal"}, ""))
  1258  
  1259  	pattern_Greeter_SayHello_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "floatval", "floatVal"}, ""))
  1260  
  1261  	pattern_Greeter_SayHello_3 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "doubleval", "doubleVal"}, ""))
  1262  
  1263  	pattern_Greeter_SayHello_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "boolval", "boolVal"}, ""))
  1264  
  1265  	pattern_Greeter_SayHello_5 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "bytesval", "bytesVal"}, ""))
  1266  
  1267  	pattern_Greeter_SayHello_6 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "int32val", "int32Val"}, ""))
  1268  
  1269  	pattern_Greeter_SayHello_7 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "uint32val", "uint32Val"}, ""))
  1270  
  1271  	pattern_Greeter_SayHello_8 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "int64val", "int64Val"}, ""))
  1272  
  1273  	pattern_Greeter_SayHello_9 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"say", "uint64val", "uint64Val"}, ""))
  1274  )
  1275  
  1276  var (
  1277  	forward_Greeter_SayHello_0 = runtime.ForwardResponseMessage
  1278  
  1279  	forward_Greeter_SayHello_1 = runtime.ForwardResponseMessage
  1280  
  1281  	forward_Greeter_SayHello_2 = runtime.ForwardResponseMessage
  1282  
  1283  	forward_Greeter_SayHello_3 = runtime.ForwardResponseMessage
  1284  
  1285  	forward_Greeter_SayHello_4 = runtime.ForwardResponseMessage
  1286  
  1287  	forward_Greeter_SayHello_5 = runtime.ForwardResponseMessage
  1288  
  1289  	forward_Greeter_SayHello_6 = runtime.ForwardResponseMessage
  1290  
  1291  	forward_Greeter_SayHello_7 = runtime.ForwardResponseMessage
  1292  
  1293  	forward_Greeter_SayHello_8 = runtime.ForwardResponseMessage
  1294  
  1295  	forward_Greeter_SayHello_9 = runtime.ForwardResponseMessage
  1296  )
  1297  

View as plain text