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

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

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: examples/internal/proto/examplepb/echo_service.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/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_EchoService_Echo_0 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
    36  )
    37  
    38  func request_EchoService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    39  	var protoReq SimpleMessage
    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["id"]
    50  	if !ok {
    51  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
    52  	}
    53  
    54  	protoReq.Id, err = runtime.String(val)
    55  	if err != nil {
    56  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", 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_EchoService_Echo_0); err != nil {
    63  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    64  	}
    65  
    66  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    67  	return msg, metadata, err
    68  
    69  }
    70  
    71  func local_request_EchoService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    72  	var protoReq SimpleMessage
    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["id"]
    83  	if !ok {
    84  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
    85  	}
    86  
    87  	protoReq.Id, err = runtime.String(val)
    88  	if err != nil {
    89  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", 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_EchoService_Echo_0); err != nil {
    96  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    97  	}
    98  
    99  	msg, err := server.Echo(ctx, &protoReq)
   100  	return msg, metadata, err
   101  
   102  }
   103  
   104  var (
   105  	filter_EchoService_Echo_1 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0, "num": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
   106  )
   107  
   108  func request_EchoService_Echo_1(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   109  	var protoReq SimpleMessage
   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["id"]
   120  	if !ok {
   121  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   122  	}
   123  
   124  	protoReq.Id, err = runtime.String(val)
   125  	if err != nil {
   126  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   127  	}
   128  
   129  	val, ok = pathParams["num"]
   130  	if !ok {
   131  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "num")
   132  	}
   133  
   134  	protoReq.Num, err = runtime.Int64(val)
   135  	if err != nil {
   136  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "num", err)
   137  	}
   138  
   139  	if err := req.ParseForm(); err != nil {
   140  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   141  	}
   142  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_1); err != nil {
   143  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   144  	}
   145  
   146  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   147  	return msg, metadata, err
   148  
   149  }
   150  
   151  func local_request_EchoService_Echo_1(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   152  	var protoReq SimpleMessage
   153  	var metadata runtime.ServerMetadata
   154  
   155  	var (
   156  		val string
   157  		ok  bool
   158  		err error
   159  		_   = err
   160  	)
   161  
   162  	val, ok = pathParams["id"]
   163  	if !ok {
   164  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   165  	}
   166  
   167  	protoReq.Id, err = runtime.String(val)
   168  	if err != nil {
   169  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   170  	}
   171  
   172  	val, ok = pathParams["num"]
   173  	if !ok {
   174  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "num")
   175  	}
   176  
   177  	protoReq.Num, err = runtime.Int64(val)
   178  	if err != nil {
   179  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "num", err)
   180  	}
   181  
   182  	if err := req.ParseForm(); err != nil {
   183  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   184  	}
   185  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_1); err != nil {
   186  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   187  	}
   188  
   189  	msg, err := server.Echo(ctx, &protoReq)
   190  	return msg, metadata, err
   191  
   192  }
   193  
   194  var (
   195  	filter_EchoService_Echo_2 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0, "num": 1, "lang": 2}, Base: []int{1, 1, 2, 3, 0, 0, 0}, Check: []int{0, 1, 1, 1, 2, 3, 4}}
   196  )
   197  
   198  func request_EchoService_Echo_2(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   199  	var protoReq SimpleMessage
   200  	var metadata runtime.ServerMetadata
   201  
   202  	var (
   203  		val string
   204  		ok  bool
   205  		err error
   206  		_   = err
   207  	)
   208  
   209  	val, ok = pathParams["id"]
   210  	if !ok {
   211  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   212  	}
   213  
   214  	protoReq.Id, err = runtime.String(val)
   215  	if err != nil {
   216  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   217  	}
   218  
   219  	val, ok = pathParams["num"]
   220  	if !ok {
   221  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "num")
   222  	}
   223  
   224  	protoReq.Num, err = runtime.Int64(val)
   225  	if err != nil {
   226  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "num", err)
   227  	}
   228  
   229  	val, ok = pathParams["lang"]
   230  	if !ok {
   231  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "lang")
   232  	}
   233  
   234  	if protoReq.Code == nil {
   235  		protoReq.Code = &SimpleMessage_Lang{}
   236  	} else if _, ok := protoReq.Code.(*SimpleMessage_Lang); !ok {
   237  		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *SimpleMessage_Lang, but: %t\n", protoReq.Code)
   238  	}
   239  	protoReq.Code.(*SimpleMessage_Lang).Lang, err = runtime.String(val)
   240  	if err != nil {
   241  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "lang", err)
   242  	}
   243  
   244  	if err := req.ParseForm(); err != nil {
   245  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   246  	}
   247  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_2); err != nil {
   248  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   249  	}
   250  
   251  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   252  	return msg, metadata, err
   253  
   254  }
   255  
   256  func local_request_EchoService_Echo_2(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   257  	var protoReq SimpleMessage
   258  	var metadata runtime.ServerMetadata
   259  
   260  	var (
   261  		val string
   262  		ok  bool
   263  		err error
   264  		_   = err
   265  	)
   266  
   267  	val, ok = pathParams["id"]
   268  	if !ok {
   269  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   270  	}
   271  
   272  	protoReq.Id, err = runtime.String(val)
   273  	if err != nil {
   274  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   275  	}
   276  
   277  	val, ok = pathParams["num"]
   278  	if !ok {
   279  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "num")
   280  	}
   281  
   282  	protoReq.Num, err = runtime.Int64(val)
   283  	if err != nil {
   284  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "num", err)
   285  	}
   286  
   287  	val, ok = pathParams["lang"]
   288  	if !ok {
   289  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "lang")
   290  	}
   291  
   292  	if protoReq.Code == nil {
   293  		protoReq.Code = &SimpleMessage_Lang{}
   294  	} else if _, ok := protoReq.Code.(*SimpleMessage_Lang); !ok {
   295  		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *SimpleMessage_Lang, but: %t\n", protoReq.Code)
   296  	}
   297  	protoReq.Code.(*SimpleMessage_Lang).Lang, err = runtime.String(val)
   298  	if err != nil {
   299  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "lang", 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_EchoService_Echo_2); err != nil {
   306  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   307  	}
   308  
   309  	msg, err := server.Echo(ctx, &protoReq)
   310  	return msg, metadata, err
   311  
   312  }
   313  
   314  var (
   315  	filter_EchoService_Echo_3 = &utilities.DoubleArray{Encoding: map[string]int{"id": 0, "line_num": 1, "status": 2, "note": 3}, Base: []int{1, 1, 2, 1, 3, 0, 0, 0}, Check: []int{0, 1, 1, 1, 4, 2, 3, 5}}
   316  )
   317  
   318  func request_EchoService_Echo_3(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   319  	var protoReq SimpleMessage
   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["id"]
   330  	if !ok {
   331  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   332  	}
   333  
   334  	protoReq.Id, err = runtime.String(val)
   335  	if err != nil {
   336  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   337  	}
   338  
   339  	val, ok = pathParams["line_num"]
   340  	if !ok {
   341  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "line_num")
   342  	}
   343  
   344  	if protoReq.Code == nil {
   345  		protoReq.Code = &SimpleMessage_LineNum{}
   346  	} else if _, ok := protoReq.Code.(*SimpleMessage_LineNum); !ok {
   347  		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *SimpleMessage_LineNum, but: %t\n", protoReq.Code)
   348  	}
   349  	protoReq.Code.(*SimpleMessage_LineNum).LineNum, err = runtime.Int64(val)
   350  	if err != nil {
   351  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "line_num", err)
   352  	}
   353  
   354  	val, ok = pathParams["status.note"]
   355  	if !ok {
   356  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "status.note")
   357  	}
   358  
   359  	err = runtime.PopulateFieldFromPath(&protoReq, "status.note", val)
   360  	if err != nil {
   361  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "status.note", err)
   362  	}
   363  
   364  	if err := req.ParseForm(); err != nil {
   365  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   366  	}
   367  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_3); err != nil {
   368  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   369  	}
   370  
   371  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   372  	return msg, metadata, err
   373  
   374  }
   375  
   376  func local_request_EchoService_Echo_3(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   377  	var protoReq SimpleMessage
   378  	var metadata runtime.ServerMetadata
   379  
   380  	var (
   381  		val string
   382  		ok  bool
   383  		err error
   384  		_   = err
   385  	)
   386  
   387  	val, ok = pathParams["id"]
   388  	if !ok {
   389  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   390  	}
   391  
   392  	protoReq.Id, err = runtime.String(val)
   393  	if err != nil {
   394  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   395  	}
   396  
   397  	val, ok = pathParams["line_num"]
   398  	if !ok {
   399  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "line_num")
   400  	}
   401  
   402  	if protoReq.Code == nil {
   403  		protoReq.Code = &SimpleMessage_LineNum{}
   404  	} else if _, ok := protoReq.Code.(*SimpleMessage_LineNum); !ok {
   405  		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *SimpleMessage_LineNum, but: %t\n", protoReq.Code)
   406  	}
   407  	protoReq.Code.(*SimpleMessage_LineNum).LineNum, err = runtime.Int64(val)
   408  	if err != nil {
   409  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "line_num", err)
   410  	}
   411  
   412  	val, ok = pathParams["status.note"]
   413  	if !ok {
   414  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "status.note")
   415  	}
   416  
   417  	err = runtime.PopulateFieldFromPath(&protoReq, "status.note", val)
   418  	if err != nil {
   419  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "status.note", err)
   420  	}
   421  
   422  	if err := req.ParseForm(); err != nil {
   423  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   424  	}
   425  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_3); err != nil {
   426  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   427  	}
   428  
   429  	msg, err := server.Echo(ctx, &protoReq)
   430  	return msg, metadata, err
   431  
   432  }
   433  
   434  var (
   435  	filter_EchoService_Echo_4 = &utilities.DoubleArray{Encoding: map[string]int{"no": 0, "note": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}}
   436  )
   437  
   438  func request_EchoService_Echo_4(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   439  	var protoReq SimpleMessage
   440  	var metadata runtime.ServerMetadata
   441  
   442  	var (
   443  		val string
   444  		ok  bool
   445  		err error
   446  		_   = err
   447  	)
   448  
   449  	val, ok = pathParams["no.note"]
   450  	if !ok {
   451  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "no.note")
   452  	}
   453  
   454  	err = runtime.PopulateFieldFromPath(&protoReq, "no.note", val)
   455  	if err != nil {
   456  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "no.note", err)
   457  	}
   458  
   459  	if err := req.ParseForm(); err != nil {
   460  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   461  	}
   462  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_4); err != nil {
   463  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   464  	}
   465  
   466  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   467  	return msg, metadata, err
   468  
   469  }
   470  
   471  func local_request_EchoService_Echo_4(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   472  	var protoReq SimpleMessage
   473  	var metadata runtime.ServerMetadata
   474  
   475  	var (
   476  		val string
   477  		ok  bool
   478  		err error
   479  		_   = err
   480  	)
   481  
   482  	val, ok = pathParams["no.note"]
   483  	if !ok {
   484  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "no.note")
   485  	}
   486  
   487  	err = runtime.PopulateFieldFromPath(&protoReq, "no.note", val)
   488  	if err != nil {
   489  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "no.note", err)
   490  	}
   491  
   492  	if err := req.ParseForm(); err != nil {
   493  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   494  	}
   495  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_4); err != nil {
   496  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   497  	}
   498  
   499  	msg, err := server.Echo(ctx, &protoReq)
   500  	return msg, metadata, err
   501  
   502  }
   503  
   504  var (
   505  	filter_EchoService_Echo_5 = &utilities.DoubleArray{Encoding: map[string]int{"resource_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   506  )
   507  
   508  func request_EchoService_Echo_5(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   509  	var protoReq SimpleMessage
   510  	var metadata runtime.ServerMetadata
   511  
   512  	var (
   513  		val string
   514  		ok  bool
   515  		err error
   516  		_   = err
   517  	)
   518  
   519  	val, ok = pathParams["resource_id"]
   520  	if !ok {
   521  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_id")
   522  	}
   523  
   524  	protoReq.ResourceId, err = runtime.String(val)
   525  	if err != nil {
   526  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_id", err)
   527  	}
   528  
   529  	if err := req.ParseForm(); err != nil {
   530  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   531  	}
   532  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_5); err != nil {
   533  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   534  	}
   535  
   536  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   537  	return msg, metadata, err
   538  
   539  }
   540  
   541  func local_request_EchoService_Echo_5(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   542  	var protoReq SimpleMessage
   543  	var metadata runtime.ServerMetadata
   544  
   545  	var (
   546  		val string
   547  		ok  bool
   548  		err error
   549  		_   = err
   550  	)
   551  
   552  	val, ok = pathParams["resource_id"]
   553  	if !ok {
   554  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "resource_id")
   555  	}
   556  
   557  	protoReq.ResourceId, err = runtime.String(val)
   558  	if err != nil {
   559  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "resource_id", err)
   560  	}
   561  
   562  	if err := req.ParseForm(); err != nil {
   563  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   564  	}
   565  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_5); err != nil {
   566  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   567  	}
   568  
   569  	msg, err := server.Echo(ctx, &protoReq)
   570  	return msg, metadata, err
   571  
   572  }
   573  
   574  var (
   575  	filter_EchoService_Echo_6 = &utilities.DoubleArray{Encoding: map[string]int{"n_id": 0}, Base: []int{1, 2, 2, 0}, Check: []int{0, 1, 2, 3}}
   576  )
   577  
   578  func request_EchoService_Echo_6(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   579  	var protoReq SimpleMessage
   580  	var metadata runtime.ServerMetadata
   581  
   582  	var (
   583  		val string
   584  		ok  bool
   585  		err error
   586  		_   = err
   587  	)
   588  
   589  	val, ok = pathParams["n_id.n_id"]
   590  	if !ok {
   591  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "n_id.n_id")
   592  	}
   593  
   594  	err = runtime.PopulateFieldFromPath(&protoReq, "n_id.n_id", val)
   595  	if err != nil {
   596  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "n_id.n_id", err)
   597  	}
   598  
   599  	if err := req.ParseForm(); err != nil {
   600  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   601  	}
   602  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_6); err != nil {
   603  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   604  	}
   605  
   606  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   607  	return msg, metadata, err
   608  
   609  }
   610  
   611  func local_request_EchoService_Echo_6(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   612  	var protoReq SimpleMessage
   613  	var metadata runtime.ServerMetadata
   614  
   615  	var (
   616  		val string
   617  		ok  bool
   618  		err error
   619  		_   = err
   620  	)
   621  
   622  	val, ok = pathParams["n_id.n_id"]
   623  	if !ok {
   624  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "n_id.n_id")
   625  	}
   626  
   627  	err = runtime.PopulateFieldFromPath(&protoReq, "n_id.n_id", val)
   628  	if err != nil {
   629  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "n_id.n_id", err)
   630  	}
   631  
   632  	if err := req.ParseForm(); err != nil {
   633  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   634  	}
   635  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_Echo_6); err != nil {
   636  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   637  	}
   638  
   639  	msg, err := server.Echo(ctx, &protoReq)
   640  	return msg, metadata, err
   641  
   642  }
   643  
   644  func request_EchoService_EchoBody_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   645  	var protoReq SimpleMessage
   646  	var metadata runtime.ServerMetadata
   647  
   648  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   649  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   650  	}
   651  
   652  	msg, err := client.EchoBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   653  	return msg, metadata, err
   654  
   655  }
   656  
   657  func local_request_EchoService_EchoBody_0(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   658  	var protoReq SimpleMessage
   659  	var metadata runtime.ServerMetadata
   660  
   661  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   662  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   663  	}
   664  
   665  	msg, err := server.EchoBody(ctx, &protoReq)
   666  	return msg, metadata, err
   667  
   668  }
   669  
   670  var (
   671  	filter_EchoService_EchoBody_1 = &utilities.DoubleArray{Encoding: map[string]int{"no": 0, "id": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
   672  )
   673  
   674  func request_EchoService_EchoBody_1(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   675  	var protoReq SimpleMessage
   676  	var metadata runtime.ServerMetadata
   677  
   678  	if protoReq.Ext == nil {
   679  		protoReq.Ext = &SimpleMessage_No{}
   680  	} else if _, ok := protoReq.Ext.(*SimpleMessage_No); !ok {
   681  		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *SimpleMessage_No, but: %t\n", protoReq.Ext)
   682  	}
   683  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Ext.(*SimpleMessage_No).No); err != nil && err != io.EOF {
   684  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   685  	}
   686  
   687  	var (
   688  		val string
   689  		ok  bool
   690  		err error
   691  		_   = err
   692  	)
   693  
   694  	val, ok = pathParams["id"]
   695  	if !ok {
   696  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   697  	}
   698  
   699  	protoReq.Id, err = runtime.String(val)
   700  	if err != nil {
   701  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   702  	}
   703  
   704  	if err := req.ParseForm(); err != nil {
   705  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   706  	}
   707  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoBody_1); err != nil {
   708  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   709  	}
   710  
   711  	msg, err := client.EchoBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   712  	return msg, metadata, err
   713  
   714  }
   715  
   716  func local_request_EchoService_EchoBody_1(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   717  	var protoReq SimpleMessage
   718  	var metadata runtime.ServerMetadata
   719  
   720  	if protoReq.Ext == nil {
   721  		protoReq.Ext = &SimpleMessage_No{}
   722  	} else if _, ok := protoReq.Ext.(*SimpleMessage_No); !ok {
   723  		return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *SimpleMessage_No, but: %t\n", protoReq.Ext)
   724  	}
   725  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Ext.(*SimpleMessage_No).No); err != nil && err != io.EOF {
   726  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   727  	}
   728  
   729  	var (
   730  		val string
   731  		ok  bool
   732  		err error
   733  		_   = err
   734  	)
   735  
   736  	val, ok = pathParams["id"]
   737  	if !ok {
   738  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
   739  	}
   740  
   741  	protoReq.Id, err = runtime.String(val)
   742  	if err != nil {
   743  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
   744  	}
   745  
   746  	if err := req.ParseForm(); err != nil {
   747  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   748  	}
   749  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoBody_1); err != nil {
   750  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   751  	}
   752  
   753  	msg, err := server.EchoBody(ctx, &protoReq)
   754  	return msg, metadata, err
   755  
   756  }
   757  
   758  var (
   759  	filter_EchoService_EchoDelete_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
   760  )
   761  
   762  func request_EchoService_EchoDelete_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   763  	var protoReq SimpleMessage
   764  	var metadata runtime.ServerMetadata
   765  
   766  	if err := req.ParseForm(); err != nil {
   767  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   768  	}
   769  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoDelete_0); err != nil {
   770  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   771  	}
   772  
   773  	msg, err := client.EchoDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   774  	return msg, metadata, err
   775  
   776  }
   777  
   778  func local_request_EchoService_EchoDelete_0(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   779  	var protoReq SimpleMessage
   780  	var metadata runtime.ServerMetadata
   781  
   782  	if err := req.ParseForm(); err != nil {
   783  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   784  	}
   785  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoDelete_0); err != nil {
   786  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   787  	}
   788  
   789  	msg, err := server.EchoDelete(ctx, &protoReq)
   790  	return msg, metadata, err
   791  
   792  }
   793  
   794  var (
   795  	filter_EchoService_EchoPatch_0 = &utilities.DoubleArray{Encoding: map[string]int{"body": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   796  )
   797  
   798  func request_EchoService_EchoPatch_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   799  	var protoReq DynamicMessageUpdate
   800  	var metadata runtime.ServerMetadata
   801  
   802  	newReader, berr := utilities.IOReaderFactory(req.Body)
   803  	if berr != nil {
   804  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   805  	}
   806  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Body); err != nil && err != io.EOF {
   807  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   808  	}
   809  	if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
   810  		if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Body); err != nil {
   811  			return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   812  		} else {
   813  			protoReq.UpdateMask = fieldMask
   814  		}
   815  	}
   816  
   817  	if err := req.ParseForm(); err != nil {
   818  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   819  	}
   820  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoPatch_0); err != nil {
   821  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   822  	}
   823  
   824  	msg, err := client.EchoPatch(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   825  	return msg, metadata, err
   826  
   827  }
   828  
   829  func local_request_EchoService_EchoPatch_0(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   830  	var protoReq DynamicMessageUpdate
   831  	var metadata runtime.ServerMetadata
   832  
   833  	newReader, berr := utilities.IOReaderFactory(req.Body)
   834  	if berr != nil {
   835  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   836  	}
   837  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Body); err != nil && err != io.EOF {
   838  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   839  	}
   840  	if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 {
   841  		if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Body); err != nil {
   842  			return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   843  		} else {
   844  			protoReq.UpdateMask = fieldMask
   845  		}
   846  	}
   847  
   848  	if err := req.ParseForm(); err != nil {
   849  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   850  	}
   851  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoPatch_0); err != nil {
   852  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   853  	}
   854  
   855  	msg, err := server.EchoPatch(ctx, &protoReq)
   856  	return msg, metadata, err
   857  
   858  }
   859  
   860  var (
   861  	filter_EchoService_EchoUnauthorized_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
   862  )
   863  
   864  func request_EchoService_EchoUnauthorized_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   865  	var protoReq SimpleMessage
   866  	var metadata runtime.ServerMetadata
   867  
   868  	if err := req.ParseForm(); err != nil {
   869  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   870  	}
   871  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoUnauthorized_0); err != nil {
   872  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   873  	}
   874  
   875  	msg, err := client.EchoUnauthorized(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   876  	return msg, metadata, err
   877  
   878  }
   879  
   880  func local_request_EchoService_EchoUnauthorized_0(ctx context.Context, marshaler runtime.Marshaler, server EchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   881  	var protoReq SimpleMessage
   882  	var metadata runtime.ServerMetadata
   883  
   884  	if err := req.ParseForm(); err != nil {
   885  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   886  	}
   887  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_EchoService_EchoUnauthorized_0); err != nil {
   888  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   889  	}
   890  
   891  	msg, err := server.EchoUnauthorized(ctx, &protoReq)
   892  	return msg, metadata, err
   893  
   894  }
   895  
   896  // RegisterEchoServiceHandlerServer registers the http handlers for service EchoService to "mux".
   897  // UnaryRPC     :call EchoServiceServer directly.
   898  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   899  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterEchoServiceHandlerFromEndpoint instead.
   900  func RegisterEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server EchoServiceServer) error {
   901  
   902  	mux.Handle("POST", pattern_EchoService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   903  		ctx, cancel := context.WithCancel(req.Context())
   904  		defer cancel()
   905  		var stream runtime.ServerTransportStream
   906  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   907  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   908  		var err error
   909  		var annotatedContext context.Context
   910  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/{id}"))
   911  		if err != nil {
   912  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   913  			return
   914  		}
   915  		resp, md, err := local_request_EchoService_Echo_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   916  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   917  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   918  		if err != nil {
   919  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   920  			return
   921  		}
   922  
   923  		forward_EchoService_Echo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   924  
   925  	})
   926  
   927  	mux.Handle("GET", pattern_EchoService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   928  		ctx, cancel := context.WithCancel(req.Context())
   929  		defer cancel()
   930  		var stream runtime.ServerTransportStream
   931  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   932  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   933  		var err error
   934  		var annotatedContext context.Context
   935  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/{id}/{num}"))
   936  		if err != nil {
   937  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   938  			return
   939  		}
   940  		resp, md, err := local_request_EchoService_Echo_1(annotatedContext, inboundMarshaler, server, req, pathParams)
   941  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   942  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   943  		if err != nil {
   944  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   945  			return
   946  		}
   947  
   948  		forward_EchoService_Echo_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   949  
   950  	})
   951  
   952  	mux.Handle("GET", pattern_EchoService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   953  		ctx, cancel := context.WithCancel(req.Context())
   954  		defer cancel()
   955  		var stream runtime.ServerTransportStream
   956  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   957  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   958  		var err error
   959  		var annotatedContext context.Context
   960  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/{id}/{num}/{lang}"))
   961  		if err != nil {
   962  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   963  			return
   964  		}
   965  		resp, md, err := local_request_EchoService_Echo_2(annotatedContext, inboundMarshaler, server, req, pathParams)
   966  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   967  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   968  		if err != nil {
   969  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   970  			return
   971  		}
   972  
   973  		forward_EchoService_Echo_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   974  
   975  	})
   976  
   977  	mux.Handle("GET", pattern_EchoService_Echo_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   978  		ctx, cancel := context.WithCancel(req.Context())
   979  		defer cancel()
   980  		var stream runtime.ServerTransportStream
   981  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   982  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   983  		var err error
   984  		var annotatedContext context.Context
   985  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo1/{id}/{line_num}/{status.note}"))
   986  		if err != nil {
   987  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   988  			return
   989  		}
   990  		resp, md, err := local_request_EchoService_Echo_3(annotatedContext, inboundMarshaler, server, req, pathParams)
   991  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   992  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   993  		if err != nil {
   994  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   995  			return
   996  		}
   997  
   998  		forward_EchoService_Echo_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   999  
  1000  	})
  1001  
  1002  	mux.Handle("GET", pattern_EchoService_Echo_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1003  		ctx, cancel := context.WithCancel(req.Context())
  1004  		defer cancel()
  1005  		var stream runtime.ServerTransportStream
  1006  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1007  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1008  		var err error
  1009  		var annotatedContext context.Context
  1010  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo2/{no.note}"))
  1011  		if err != nil {
  1012  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1013  			return
  1014  		}
  1015  		resp, md, err := local_request_EchoService_Echo_4(annotatedContext, inboundMarshaler, server, req, pathParams)
  1016  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1017  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1018  		if err != nil {
  1019  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1020  			return
  1021  		}
  1022  
  1023  		forward_EchoService_Echo_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1024  
  1025  	})
  1026  
  1027  	mux.Handle("GET", pattern_EchoService_Echo_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1028  		ctx, cancel := context.WithCancel(req.Context())
  1029  		defer cancel()
  1030  		var stream runtime.ServerTransportStream
  1031  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1032  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1033  		var err error
  1034  		var annotatedContext context.Context
  1035  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/resource/{resource_id}"))
  1036  		if err != nil {
  1037  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1038  			return
  1039  		}
  1040  		resp, md, err := local_request_EchoService_Echo_5(annotatedContext, inboundMarshaler, server, req, pathParams)
  1041  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1042  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1043  		if err != nil {
  1044  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1045  			return
  1046  		}
  1047  
  1048  		forward_EchoService_Echo_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1049  
  1050  	})
  1051  
  1052  	mux.Handle("GET", pattern_EchoService_Echo_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1053  		ctx, cancel := context.WithCancel(req.Context())
  1054  		defer cancel()
  1055  		var stream runtime.ServerTransportStream
  1056  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1057  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1058  		var err error
  1059  		var annotatedContext context.Context
  1060  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/nested/{n_id.n_id}"))
  1061  		if err != nil {
  1062  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1063  			return
  1064  		}
  1065  		resp, md, err := local_request_EchoService_Echo_6(annotatedContext, inboundMarshaler, server, req, pathParams)
  1066  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1067  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1068  		if err != nil {
  1069  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1070  			return
  1071  		}
  1072  
  1073  		forward_EchoService_Echo_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1074  
  1075  	})
  1076  
  1077  	mux.Handle("POST", pattern_EchoService_EchoBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1078  		ctx, cancel := context.WithCancel(req.Context())
  1079  		defer cancel()
  1080  		var stream runtime.ServerTransportStream
  1081  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1082  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1083  		var err error
  1084  		var annotatedContext context.Context
  1085  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoBody", runtime.WithHTTPPathPattern("/v1/example/echo_body"))
  1086  		if err != nil {
  1087  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1088  			return
  1089  		}
  1090  		resp, md, err := local_request_EchoService_EchoBody_0(annotatedContext, inboundMarshaler, server, req, pathParams)
  1091  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1092  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1093  		if err != nil {
  1094  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1095  			return
  1096  		}
  1097  
  1098  		forward_EchoService_EchoBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1099  
  1100  	})
  1101  
  1102  	mux.Handle("PUT", pattern_EchoService_EchoBody_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1103  		ctx, cancel := context.WithCancel(req.Context())
  1104  		defer cancel()
  1105  		var stream runtime.ServerTransportStream
  1106  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1107  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1108  		var err error
  1109  		var annotatedContext context.Context
  1110  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoBody", runtime.WithHTTPPathPattern("/v1/example/echo_body/{id}"))
  1111  		if err != nil {
  1112  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1113  			return
  1114  		}
  1115  		resp, md, err := local_request_EchoService_EchoBody_1(annotatedContext, inboundMarshaler, server, req, pathParams)
  1116  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1117  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1118  		if err != nil {
  1119  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1120  			return
  1121  		}
  1122  
  1123  		forward_EchoService_EchoBody_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1124  
  1125  	})
  1126  
  1127  	mux.Handle("DELETE", pattern_EchoService_EchoDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1128  		ctx, cancel := context.WithCancel(req.Context())
  1129  		defer cancel()
  1130  		var stream runtime.ServerTransportStream
  1131  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1132  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1133  		var err error
  1134  		var annotatedContext context.Context
  1135  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoDelete", runtime.WithHTTPPathPattern("/v1/example/echo_delete"))
  1136  		if err != nil {
  1137  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1138  			return
  1139  		}
  1140  		resp, md, err := local_request_EchoService_EchoDelete_0(annotatedContext, inboundMarshaler, server, req, pathParams)
  1141  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1142  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1143  		if err != nil {
  1144  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1145  			return
  1146  		}
  1147  
  1148  		forward_EchoService_EchoDelete_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1149  
  1150  	})
  1151  
  1152  	mux.Handle("PATCH", pattern_EchoService_EchoPatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1153  		ctx, cancel := context.WithCancel(req.Context())
  1154  		defer cancel()
  1155  		var stream runtime.ServerTransportStream
  1156  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1157  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1158  		var err error
  1159  		var annotatedContext context.Context
  1160  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoPatch", runtime.WithHTTPPathPattern("/v1/example/echo_patch"))
  1161  		if err != nil {
  1162  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1163  			return
  1164  		}
  1165  		resp, md, err := local_request_EchoService_EchoPatch_0(annotatedContext, inboundMarshaler, server, req, pathParams)
  1166  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1167  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1168  		if err != nil {
  1169  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1170  			return
  1171  		}
  1172  
  1173  		forward_EchoService_EchoPatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1174  
  1175  	})
  1176  
  1177  	mux.Handle("GET", pattern_EchoService_EchoUnauthorized_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1178  		ctx, cancel := context.WithCancel(req.Context())
  1179  		defer cancel()
  1180  		var stream runtime.ServerTransportStream
  1181  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
  1182  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1183  		var err error
  1184  		var annotatedContext context.Context
  1185  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoUnauthorized", runtime.WithHTTPPathPattern("/v1/example/echo_unauthorized"))
  1186  		if err != nil {
  1187  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1188  			return
  1189  		}
  1190  		resp, md, err := local_request_EchoService_EchoUnauthorized_0(annotatedContext, inboundMarshaler, server, req, pathParams)
  1191  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
  1192  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1193  		if err != nil {
  1194  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1195  			return
  1196  		}
  1197  
  1198  		forward_EchoService_EchoUnauthorized_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1199  
  1200  	})
  1201  
  1202  	return nil
  1203  }
  1204  
  1205  // RegisterEchoServiceHandlerFromEndpoint is same as RegisterEchoServiceHandler but
  1206  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  1207  func RegisterEchoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  1208  	conn, err := grpc.DialContext(ctx, endpoint, opts...)
  1209  	if err != nil {
  1210  		return err
  1211  	}
  1212  	defer func() {
  1213  		if err != nil {
  1214  			if cerr := conn.Close(); cerr != nil {
  1215  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  1216  			}
  1217  			return
  1218  		}
  1219  		go func() {
  1220  			<-ctx.Done()
  1221  			if cerr := conn.Close(); cerr != nil {
  1222  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  1223  			}
  1224  		}()
  1225  	}()
  1226  
  1227  	return RegisterEchoServiceHandler(ctx, mux, conn)
  1228  }
  1229  
  1230  // RegisterEchoServiceHandler registers the http handlers for service EchoService to "mux".
  1231  // The handlers forward requests to the grpc endpoint over "conn".
  1232  func RegisterEchoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  1233  	return RegisterEchoServiceHandlerClient(ctx, mux, NewEchoServiceClient(conn))
  1234  }
  1235  
  1236  // RegisterEchoServiceHandlerClient registers the http handlers for service EchoService
  1237  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "EchoServiceClient".
  1238  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "EchoServiceClient"
  1239  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  1240  // "EchoServiceClient" to call the correct interceptors.
  1241  func RegisterEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client EchoServiceClient) error {
  1242  
  1243  	mux.Handle("POST", pattern_EchoService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1244  		ctx, cancel := context.WithCancel(req.Context())
  1245  		defer cancel()
  1246  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1247  		var err error
  1248  		var annotatedContext context.Context
  1249  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/{id}"))
  1250  		if err != nil {
  1251  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1252  			return
  1253  		}
  1254  		resp, md, err := request_EchoService_Echo_0(annotatedContext, inboundMarshaler, client, req, pathParams)
  1255  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1256  		if err != nil {
  1257  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1258  			return
  1259  		}
  1260  
  1261  		forward_EchoService_Echo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1262  
  1263  	})
  1264  
  1265  	mux.Handle("GET", pattern_EchoService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1266  		ctx, cancel := context.WithCancel(req.Context())
  1267  		defer cancel()
  1268  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1269  		var err error
  1270  		var annotatedContext context.Context
  1271  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/{id}/{num}"))
  1272  		if err != nil {
  1273  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1274  			return
  1275  		}
  1276  		resp, md, err := request_EchoService_Echo_1(annotatedContext, inboundMarshaler, client, req, pathParams)
  1277  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1278  		if err != nil {
  1279  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1280  			return
  1281  		}
  1282  
  1283  		forward_EchoService_Echo_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1284  
  1285  	})
  1286  
  1287  	mux.Handle("GET", pattern_EchoService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1288  		ctx, cancel := context.WithCancel(req.Context())
  1289  		defer cancel()
  1290  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1291  		var err error
  1292  		var annotatedContext context.Context
  1293  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/{id}/{num}/{lang}"))
  1294  		if err != nil {
  1295  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1296  			return
  1297  		}
  1298  		resp, md, err := request_EchoService_Echo_2(annotatedContext, inboundMarshaler, client, req, pathParams)
  1299  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1300  		if err != nil {
  1301  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1302  			return
  1303  		}
  1304  
  1305  		forward_EchoService_Echo_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1306  
  1307  	})
  1308  
  1309  	mux.Handle("GET", pattern_EchoService_Echo_3, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1310  		ctx, cancel := context.WithCancel(req.Context())
  1311  		defer cancel()
  1312  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1313  		var err error
  1314  		var annotatedContext context.Context
  1315  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo1/{id}/{line_num}/{status.note}"))
  1316  		if err != nil {
  1317  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1318  			return
  1319  		}
  1320  		resp, md, err := request_EchoService_Echo_3(annotatedContext, inboundMarshaler, client, req, pathParams)
  1321  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1322  		if err != nil {
  1323  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1324  			return
  1325  		}
  1326  
  1327  		forward_EchoService_Echo_3(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1328  
  1329  	})
  1330  
  1331  	mux.Handle("GET", pattern_EchoService_Echo_4, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1332  		ctx, cancel := context.WithCancel(req.Context())
  1333  		defer cancel()
  1334  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1335  		var err error
  1336  		var annotatedContext context.Context
  1337  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo2/{no.note}"))
  1338  		if err != nil {
  1339  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1340  			return
  1341  		}
  1342  		resp, md, err := request_EchoService_Echo_4(annotatedContext, inboundMarshaler, client, req, pathParams)
  1343  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1344  		if err != nil {
  1345  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1346  			return
  1347  		}
  1348  
  1349  		forward_EchoService_Echo_4(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1350  
  1351  	})
  1352  
  1353  	mux.Handle("GET", pattern_EchoService_Echo_5, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1354  		ctx, cancel := context.WithCancel(req.Context())
  1355  		defer cancel()
  1356  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1357  		var err error
  1358  		var annotatedContext context.Context
  1359  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/resource/{resource_id}"))
  1360  		if err != nil {
  1361  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1362  			return
  1363  		}
  1364  		resp, md, err := request_EchoService_Echo_5(annotatedContext, inboundMarshaler, client, req, pathParams)
  1365  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1366  		if err != nil {
  1367  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1368  			return
  1369  		}
  1370  
  1371  		forward_EchoService_Echo_5(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1372  
  1373  	})
  1374  
  1375  	mux.Handle("GET", pattern_EchoService_Echo_6, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1376  		ctx, cancel := context.WithCancel(req.Context())
  1377  		defer cancel()
  1378  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1379  		var err error
  1380  		var annotatedContext context.Context
  1381  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo", runtime.WithHTTPPathPattern("/v1/example/echo/nested/{n_id.n_id}"))
  1382  		if err != nil {
  1383  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1384  			return
  1385  		}
  1386  		resp, md, err := request_EchoService_Echo_6(annotatedContext, inboundMarshaler, client, req, pathParams)
  1387  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1388  		if err != nil {
  1389  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1390  			return
  1391  		}
  1392  
  1393  		forward_EchoService_Echo_6(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1394  
  1395  	})
  1396  
  1397  	mux.Handle("POST", pattern_EchoService_EchoBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1398  		ctx, cancel := context.WithCancel(req.Context())
  1399  		defer cancel()
  1400  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1401  		var err error
  1402  		var annotatedContext context.Context
  1403  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoBody", runtime.WithHTTPPathPattern("/v1/example/echo_body"))
  1404  		if err != nil {
  1405  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1406  			return
  1407  		}
  1408  		resp, md, err := request_EchoService_EchoBody_0(annotatedContext, inboundMarshaler, client, req, pathParams)
  1409  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1410  		if err != nil {
  1411  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1412  			return
  1413  		}
  1414  
  1415  		forward_EchoService_EchoBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1416  
  1417  	})
  1418  
  1419  	mux.Handle("PUT", pattern_EchoService_EchoBody_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1420  		ctx, cancel := context.WithCancel(req.Context())
  1421  		defer cancel()
  1422  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1423  		var err error
  1424  		var annotatedContext context.Context
  1425  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoBody", runtime.WithHTTPPathPattern("/v1/example/echo_body/{id}"))
  1426  		if err != nil {
  1427  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1428  			return
  1429  		}
  1430  		resp, md, err := request_EchoService_EchoBody_1(annotatedContext, inboundMarshaler, client, req, pathParams)
  1431  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1432  		if err != nil {
  1433  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1434  			return
  1435  		}
  1436  
  1437  		forward_EchoService_EchoBody_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1438  
  1439  	})
  1440  
  1441  	mux.Handle("DELETE", pattern_EchoService_EchoDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1442  		ctx, cancel := context.WithCancel(req.Context())
  1443  		defer cancel()
  1444  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1445  		var err error
  1446  		var annotatedContext context.Context
  1447  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoDelete", runtime.WithHTTPPathPattern("/v1/example/echo_delete"))
  1448  		if err != nil {
  1449  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1450  			return
  1451  		}
  1452  		resp, md, err := request_EchoService_EchoDelete_0(annotatedContext, inboundMarshaler, client, req, pathParams)
  1453  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1454  		if err != nil {
  1455  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1456  			return
  1457  		}
  1458  
  1459  		forward_EchoService_EchoDelete_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1460  
  1461  	})
  1462  
  1463  	mux.Handle("PATCH", pattern_EchoService_EchoPatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1464  		ctx, cancel := context.WithCancel(req.Context())
  1465  		defer cancel()
  1466  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1467  		var err error
  1468  		var annotatedContext context.Context
  1469  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoPatch", runtime.WithHTTPPathPattern("/v1/example/echo_patch"))
  1470  		if err != nil {
  1471  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1472  			return
  1473  		}
  1474  		resp, md, err := request_EchoService_EchoPatch_0(annotatedContext, inboundMarshaler, client, req, pathParams)
  1475  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1476  		if err != nil {
  1477  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1478  			return
  1479  		}
  1480  
  1481  		forward_EchoService_EchoPatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1482  
  1483  	})
  1484  
  1485  	mux.Handle("GET", pattern_EchoService_EchoUnauthorized_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1486  		ctx, cancel := context.WithCancel(req.Context())
  1487  		defer cancel()
  1488  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1489  		var err error
  1490  		var annotatedContext context.Context
  1491  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoUnauthorized", runtime.WithHTTPPathPattern("/v1/example/echo_unauthorized"))
  1492  		if err != nil {
  1493  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1494  			return
  1495  		}
  1496  		resp, md, err := request_EchoService_EchoUnauthorized_0(annotatedContext, inboundMarshaler, client, req, pathParams)
  1497  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
  1498  		if err != nil {
  1499  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
  1500  			return
  1501  		}
  1502  
  1503  		forward_EchoService_EchoUnauthorized_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1504  
  1505  	})
  1506  
  1507  	return nil
  1508  }
  1509  
  1510  var (
  1511  	pattern_EchoService_Echo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "echo", "id"}, ""))
  1512  
  1513  	pattern_EchoService_Echo_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "echo", "id", "num"}, ""))
  1514  
  1515  	pattern_EchoService_Echo_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "echo", "id", "num", "lang"}, ""))
  1516  
  1517  	pattern_EchoService_Echo_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, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "echo1", "id", "line_num", "status.note"}, ""))
  1518  
  1519  	pattern_EchoService_Echo_4 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "echo2", "no.note"}, ""))
  1520  
  1521  	pattern_EchoService_Echo_5 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "echo", "resource", "resource_id"}, ""))
  1522  
  1523  	pattern_EchoService_Echo_6 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "echo", "nested", "n_id.n_id"}, ""))
  1524  
  1525  	pattern_EchoService_EchoBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "echo_body"}, ""))
  1526  
  1527  	pattern_EchoService_EchoBody_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "echo_body", "id"}, ""))
  1528  
  1529  	pattern_EchoService_EchoDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "echo_delete"}, ""))
  1530  
  1531  	pattern_EchoService_EchoPatch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "echo_patch"}, ""))
  1532  
  1533  	pattern_EchoService_EchoUnauthorized_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "echo_unauthorized"}, ""))
  1534  )
  1535  
  1536  var (
  1537  	forward_EchoService_Echo_0 = runtime.ForwardResponseMessage
  1538  
  1539  	forward_EchoService_Echo_1 = runtime.ForwardResponseMessage
  1540  
  1541  	forward_EchoService_Echo_2 = runtime.ForwardResponseMessage
  1542  
  1543  	forward_EchoService_Echo_3 = runtime.ForwardResponseMessage
  1544  
  1545  	forward_EchoService_Echo_4 = runtime.ForwardResponseMessage
  1546  
  1547  	forward_EchoService_Echo_5 = runtime.ForwardResponseMessage
  1548  
  1549  	forward_EchoService_Echo_6 = runtime.ForwardResponseMessage
  1550  
  1551  	forward_EchoService_EchoBody_0 = runtime.ForwardResponseMessage
  1552  
  1553  	forward_EchoService_EchoBody_1 = runtime.ForwardResponseMessage
  1554  
  1555  	forward_EchoService_EchoDelete_0 = runtime.ForwardResponseMessage
  1556  
  1557  	forward_EchoService_EchoPatch_0 = runtime.ForwardResponseMessage
  1558  
  1559  	forward_EchoService_EchoUnauthorized_0 = runtime.ForwardResponseMessage
  1560  )
  1561  

View as plain text