Source file src/github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/examplepb/wrappers.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/wrappers.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  	"google.golang.org/protobuf/types/known/emptypb"
    25  	"google.golang.org/protobuf/types/known/wrapperspb"
    26  )
    27  
    28  // Suppress "imported and not used" errors
    29  var _ codes.Code
    30  var _ io.Reader
    31  var _ status.Status
    32  var _ = runtime.String
    33  var _ = utilities.NewDoubleArray
    34  var _ = metadata.Join
    35  
    36  func request_WrappersService_Create_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    37  	var protoReq Wrappers
    38  	var metadata runtime.ServerMetadata
    39  
    40  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
    41  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    42  	}
    43  
    44  	msg, err := client.Create(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    45  	return msg, metadata, err
    46  
    47  }
    48  
    49  func local_request_WrappersService_Create_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    50  	var protoReq Wrappers
    51  	var metadata runtime.ServerMetadata
    52  
    53  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
    54  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    55  	}
    56  
    57  	msg, err := server.Create(ctx, &protoReq)
    58  	return msg, metadata, err
    59  
    60  }
    61  
    62  func request_WrappersService_CreateStringValue_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    63  	var protoReq wrapperspb.StringValue
    64  	var metadata runtime.ServerMetadata
    65  
    66  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
    67  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    68  	}
    69  
    70  	msg, err := client.CreateStringValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    71  	return msg, metadata, err
    72  
    73  }
    74  
    75  func local_request_WrappersService_CreateStringValue_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    76  	var protoReq wrapperspb.StringValue
    77  	var metadata runtime.ServerMetadata
    78  
    79  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
    80  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    81  	}
    82  
    83  	msg, err := server.CreateStringValue(ctx, &protoReq)
    84  	return msg, metadata, err
    85  
    86  }
    87  
    88  func request_WrappersService_CreateInt32Value_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    89  	var protoReq wrapperspb.Int32Value
    90  	var metadata runtime.ServerMetadata
    91  
    92  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
    93  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    94  	}
    95  
    96  	msg, err := client.CreateInt32Value(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    97  	return msg, metadata, err
    98  
    99  }
   100  
   101  func local_request_WrappersService_CreateInt32Value_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   102  	var protoReq wrapperspb.Int32Value
   103  	var metadata runtime.ServerMetadata
   104  
   105  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   106  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   107  	}
   108  
   109  	msg, err := server.CreateInt32Value(ctx, &protoReq)
   110  	return msg, metadata, err
   111  
   112  }
   113  
   114  func request_WrappersService_CreateInt64Value_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   115  	var protoReq wrapperspb.Int64Value
   116  	var metadata runtime.ServerMetadata
   117  
   118  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   119  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   120  	}
   121  
   122  	msg, err := client.CreateInt64Value(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   123  	return msg, metadata, err
   124  
   125  }
   126  
   127  func local_request_WrappersService_CreateInt64Value_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   128  	var protoReq wrapperspb.Int64Value
   129  	var metadata runtime.ServerMetadata
   130  
   131  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   132  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   133  	}
   134  
   135  	msg, err := server.CreateInt64Value(ctx, &protoReq)
   136  	return msg, metadata, err
   137  
   138  }
   139  
   140  func request_WrappersService_CreateFloatValue_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   141  	var protoReq wrapperspb.FloatValue
   142  	var metadata runtime.ServerMetadata
   143  
   144  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   145  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   146  	}
   147  
   148  	msg, err := client.CreateFloatValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   149  	return msg, metadata, err
   150  
   151  }
   152  
   153  func local_request_WrappersService_CreateFloatValue_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   154  	var protoReq wrapperspb.FloatValue
   155  	var metadata runtime.ServerMetadata
   156  
   157  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   158  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   159  	}
   160  
   161  	msg, err := server.CreateFloatValue(ctx, &protoReq)
   162  	return msg, metadata, err
   163  
   164  }
   165  
   166  func request_WrappersService_CreateDoubleValue_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   167  	var protoReq wrapperspb.DoubleValue
   168  	var metadata runtime.ServerMetadata
   169  
   170  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   171  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   172  	}
   173  
   174  	msg, err := client.CreateDoubleValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   175  	return msg, metadata, err
   176  
   177  }
   178  
   179  func local_request_WrappersService_CreateDoubleValue_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   180  	var protoReq wrapperspb.DoubleValue
   181  	var metadata runtime.ServerMetadata
   182  
   183  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   184  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   185  	}
   186  
   187  	msg, err := server.CreateDoubleValue(ctx, &protoReq)
   188  	return msg, metadata, err
   189  
   190  }
   191  
   192  func request_WrappersService_CreateBoolValue_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   193  	var protoReq wrapperspb.BoolValue
   194  	var metadata runtime.ServerMetadata
   195  
   196  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   197  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   198  	}
   199  
   200  	msg, err := client.CreateBoolValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   201  	return msg, metadata, err
   202  
   203  }
   204  
   205  func local_request_WrappersService_CreateBoolValue_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   206  	var protoReq wrapperspb.BoolValue
   207  	var metadata runtime.ServerMetadata
   208  
   209  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   210  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   211  	}
   212  
   213  	msg, err := server.CreateBoolValue(ctx, &protoReq)
   214  	return msg, metadata, err
   215  
   216  }
   217  
   218  func request_WrappersService_CreateUInt32Value_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   219  	var protoReq wrapperspb.UInt32Value
   220  	var metadata runtime.ServerMetadata
   221  
   222  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   223  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   224  	}
   225  
   226  	msg, err := client.CreateUInt32Value(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   227  	return msg, metadata, err
   228  
   229  }
   230  
   231  func local_request_WrappersService_CreateUInt32Value_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   232  	var protoReq wrapperspb.UInt32Value
   233  	var metadata runtime.ServerMetadata
   234  
   235  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   236  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   237  	}
   238  
   239  	msg, err := server.CreateUInt32Value(ctx, &protoReq)
   240  	return msg, metadata, err
   241  
   242  }
   243  
   244  func request_WrappersService_CreateUInt64Value_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   245  	var protoReq wrapperspb.UInt64Value
   246  	var metadata runtime.ServerMetadata
   247  
   248  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   249  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   250  	}
   251  
   252  	msg, err := client.CreateUInt64Value(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   253  	return msg, metadata, err
   254  
   255  }
   256  
   257  func local_request_WrappersService_CreateUInt64Value_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   258  	var protoReq wrapperspb.UInt64Value
   259  	var metadata runtime.ServerMetadata
   260  
   261  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   262  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   263  	}
   264  
   265  	msg, err := server.CreateUInt64Value(ctx, &protoReq)
   266  	return msg, metadata, err
   267  
   268  }
   269  
   270  func request_WrappersService_CreateBytesValue_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   271  	var protoReq wrapperspb.BytesValue
   272  	var metadata runtime.ServerMetadata
   273  
   274  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   275  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   276  	}
   277  
   278  	msg, err := client.CreateBytesValue(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   279  	return msg, metadata, err
   280  
   281  }
   282  
   283  func local_request_WrappersService_CreateBytesValue_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   284  	var protoReq wrapperspb.BytesValue
   285  	var metadata runtime.ServerMetadata
   286  
   287  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   288  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   289  	}
   290  
   291  	msg, err := server.CreateBytesValue(ctx, &protoReq)
   292  	return msg, metadata, err
   293  
   294  }
   295  
   296  func request_WrappersService_CreateEmpty_0(ctx context.Context, marshaler runtime.Marshaler, client WrappersServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   297  	var protoReq emptypb.Empty
   298  	var metadata runtime.ServerMetadata
   299  
   300  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   301  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   302  	}
   303  
   304  	msg, err := client.CreateEmpty(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   305  	return msg, metadata, err
   306  
   307  }
   308  
   309  func local_request_WrappersService_CreateEmpty_0(ctx context.Context, marshaler runtime.Marshaler, server WrappersServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   310  	var protoReq emptypb.Empty
   311  	var metadata runtime.ServerMetadata
   312  
   313  	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
   314  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   315  	}
   316  
   317  	msg, err := server.CreateEmpty(ctx, &protoReq)
   318  	return msg, metadata, err
   319  
   320  }
   321  
   322  // RegisterWrappersServiceHandlerServer registers the http handlers for service WrappersService to "mux".
   323  // UnaryRPC     :call WrappersServiceServer directly.
   324  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   325  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterWrappersServiceHandlerFromEndpoint instead.
   326  func RegisterWrappersServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server WrappersServiceServer) error {
   327  
   328  	mux.Handle("POST", pattern_WrappersService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   329  		ctx, cancel := context.WithCancel(req.Context())
   330  		defer cancel()
   331  		var stream runtime.ServerTransportStream
   332  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   333  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   334  		var err error
   335  		var annotatedContext context.Context
   336  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/Create", runtime.WithHTTPPathPattern("/v1/example/wrappers"))
   337  		if err != nil {
   338  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   339  			return
   340  		}
   341  		resp, md, err := local_request_WrappersService_Create_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   342  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   343  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   344  		if err != nil {
   345  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   346  			return
   347  		}
   348  
   349  		forward_WrappersService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   350  
   351  	})
   352  
   353  	mux.Handle("POST", pattern_WrappersService_CreateStringValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   354  		ctx, cancel := context.WithCancel(req.Context())
   355  		defer cancel()
   356  		var stream runtime.ServerTransportStream
   357  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   358  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   359  		var err error
   360  		var annotatedContext context.Context
   361  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateStringValue", runtime.WithHTTPPathPattern("/v1/testString"))
   362  		if err != nil {
   363  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   364  			return
   365  		}
   366  		resp, md, err := local_request_WrappersService_CreateStringValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   367  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   368  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   369  		if err != nil {
   370  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   371  			return
   372  		}
   373  
   374  		forward_WrappersService_CreateStringValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   375  
   376  	})
   377  
   378  	mux.Handle("POST", pattern_WrappersService_CreateInt32Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   379  		ctx, cancel := context.WithCancel(req.Context())
   380  		defer cancel()
   381  		var stream runtime.ServerTransportStream
   382  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   383  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   384  		var err error
   385  		var annotatedContext context.Context
   386  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateInt32Value", runtime.WithHTTPPathPattern("/v1/testInt32"))
   387  		if err != nil {
   388  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   389  			return
   390  		}
   391  		resp, md, err := local_request_WrappersService_CreateInt32Value_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   392  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   393  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   394  		if err != nil {
   395  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   396  			return
   397  		}
   398  
   399  		forward_WrappersService_CreateInt32Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   400  
   401  	})
   402  
   403  	mux.Handle("POST", pattern_WrappersService_CreateInt64Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   404  		ctx, cancel := context.WithCancel(req.Context())
   405  		defer cancel()
   406  		var stream runtime.ServerTransportStream
   407  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   408  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   409  		var err error
   410  		var annotatedContext context.Context
   411  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateInt64Value", runtime.WithHTTPPathPattern("/v1/testInt64"))
   412  		if err != nil {
   413  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   414  			return
   415  		}
   416  		resp, md, err := local_request_WrappersService_CreateInt64Value_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   417  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   418  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   419  		if err != nil {
   420  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   421  			return
   422  		}
   423  
   424  		forward_WrappersService_CreateInt64Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   425  
   426  	})
   427  
   428  	mux.Handle("POST", pattern_WrappersService_CreateFloatValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   429  		ctx, cancel := context.WithCancel(req.Context())
   430  		defer cancel()
   431  		var stream runtime.ServerTransportStream
   432  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   433  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   434  		var err error
   435  		var annotatedContext context.Context
   436  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateFloatValue", runtime.WithHTTPPathPattern("/v1/testFloat"))
   437  		if err != nil {
   438  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   439  			return
   440  		}
   441  		resp, md, err := local_request_WrappersService_CreateFloatValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   442  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   443  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   444  		if err != nil {
   445  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   446  			return
   447  		}
   448  
   449  		forward_WrappersService_CreateFloatValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   450  
   451  	})
   452  
   453  	mux.Handle("POST", pattern_WrappersService_CreateDoubleValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   454  		ctx, cancel := context.WithCancel(req.Context())
   455  		defer cancel()
   456  		var stream runtime.ServerTransportStream
   457  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   458  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   459  		var err error
   460  		var annotatedContext context.Context
   461  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateDoubleValue", runtime.WithHTTPPathPattern("/v1/testDouble"))
   462  		if err != nil {
   463  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   464  			return
   465  		}
   466  		resp, md, err := local_request_WrappersService_CreateDoubleValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   467  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   468  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   469  		if err != nil {
   470  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   471  			return
   472  		}
   473  
   474  		forward_WrappersService_CreateDoubleValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   475  
   476  	})
   477  
   478  	mux.Handle("POST", pattern_WrappersService_CreateBoolValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   479  		ctx, cancel := context.WithCancel(req.Context())
   480  		defer cancel()
   481  		var stream runtime.ServerTransportStream
   482  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   483  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   484  		var err error
   485  		var annotatedContext context.Context
   486  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateBoolValue", runtime.WithHTTPPathPattern("/v1/testBool"))
   487  		if err != nil {
   488  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   489  			return
   490  		}
   491  		resp, md, err := local_request_WrappersService_CreateBoolValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   492  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   493  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   494  		if err != nil {
   495  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   496  			return
   497  		}
   498  
   499  		forward_WrappersService_CreateBoolValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   500  
   501  	})
   502  
   503  	mux.Handle("POST", pattern_WrappersService_CreateUInt32Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   504  		ctx, cancel := context.WithCancel(req.Context())
   505  		defer cancel()
   506  		var stream runtime.ServerTransportStream
   507  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   508  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   509  		var err error
   510  		var annotatedContext context.Context
   511  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateUInt32Value", runtime.WithHTTPPathPattern("/v1/testUint32"))
   512  		if err != nil {
   513  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   514  			return
   515  		}
   516  		resp, md, err := local_request_WrappersService_CreateUInt32Value_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   517  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   518  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   519  		if err != nil {
   520  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   521  			return
   522  		}
   523  
   524  		forward_WrappersService_CreateUInt32Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   525  
   526  	})
   527  
   528  	mux.Handle("POST", pattern_WrappersService_CreateUInt64Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   529  		ctx, cancel := context.WithCancel(req.Context())
   530  		defer cancel()
   531  		var stream runtime.ServerTransportStream
   532  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   533  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   534  		var err error
   535  		var annotatedContext context.Context
   536  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateUInt64Value", runtime.WithHTTPPathPattern("/v1/testUint64"))
   537  		if err != nil {
   538  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   539  			return
   540  		}
   541  		resp, md, err := local_request_WrappersService_CreateUInt64Value_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   542  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   543  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   544  		if err != nil {
   545  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   546  			return
   547  		}
   548  
   549  		forward_WrappersService_CreateUInt64Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   550  
   551  	})
   552  
   553  	mux.Handle("POST", pattern_WrappersService_CreateBytesValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   554  		ctx, cancel := context.WithCancel(req.Context())
   555  		defer cancel()
   556  		var stream runtime.ServerTransportStream
   557  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   558  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   559  		var err error
   560  		var annotatedContext context.Context
   561  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateBytesValue", runtime.WithHTTPPathPattern("/v1/testBytes"))
   562  		if err != nil {
   563  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   564  			return
   565  		}
   566  		resp, md, err := local_request_WrappersService_CreateBytesValue_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   567  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   568  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   569  		if err != nil {
   570  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   571  			return
   572  		}
   573  
   574  		forward_WrappersService_CreateBytesValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   575  
   576  	})
   577  
   578  	mux.Handle("POST", pattern_WrappersService_CreateEmpty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   579  		ctx, cancel := context.WithCancel(req.Context())
   580  		defer cancel()
   581  		var stream runtime.ServerTransportStream
   582  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   583  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   584  		var err error
   585  		var annotatedContext context.Context
   586  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateEmpty", runtime.WithHTTPPathPattern("/v1/testEmpty"))
   587  		if err != nil {
   588  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   589  			return
   590  		}
   591  		resp, md, err := local_request_WrappersService_CreateEmpty_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   592  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   593  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   594  		if err != nil {
   595  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   596  			return
   597  		}
   598  
   599  		forward_WrappersService_CreateEmpty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   600  
   601  	})
   602  
   603  	return nil
   604  }
   605  
   606  // RegisterWrappersServiceHandlerFromEndpoint is same as RegisterWrappersServiceHandler but
   607  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   608  func RegisterWrappersServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   609  	conn, err := grpc.DialContext(ctx, endpoint, opts...)
   610  	if err != nil {
   611  		return err
   612  	}
   613  	defer func() {
   614  		if err != nil {
   615  			if cerr := conn.Close(); cerr != nil {
   616  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   617  			}
   618  			return
   619  		}
   620  		go func() {
   621  			<-ctx.Done()
   622  			if cerr := conn.Close(); cerr != nil {
   623  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   624  			}
   625  		}()
   626  	}()
   627  
   628  	return RegisterWrappersServiceHandler(ctx, mux, conn)
   629  }
   630  
   631  // RegisterWrappersServiceHandler registers the http handlers for service WrappersService to "mux".
   632  // The handlers forward requests to the grpc endpoint over "conn".
   633  func RegisterWrappersServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   634  	return RegisterWrappersServiceHandlerClient(ctx, mux, NewWrappersServiceClient(conn))
   635  }
   636  
   637  // RegisterWrappersServiceHandlerClient registers the http handlers for service WrappersService
   638  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "WrappersServiceClient".
   639  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WrappersServiceClient"
   640  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
   641  // "WrappersServiceClient" to call the correct interceptors.
   642  func RegisterWrappersServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client WrappersServiceClient) error {
   643  
   644  	mux.Handle("POST", pattern_WrappersService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   645  		ctx, cancel := context.WithCancel(req.Context())
   646  		defer cancel()
   647  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   648  		var err error
   649  		var annotatedContext context.Context
   650  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/Create", runtime.WithHTTPPathPattern("/v1/example/wrappers"))
   651  		if err != nil {
   652  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   653  			return
   654  		}
   655  		resp, md, err := request_WrappersService_Create_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   656  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   657  		if err != nil {
   658  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   659  			return
   660  		}
   661  
   662  		forward_WrappersService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   663  
   664  	})
   665  
   666  	mux.Handle("POST", pattern_WrappersService_CreateStringValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   667  		ctx, cancel := context.WithCancel(req.Context())
   668  		defer cancel()
   669  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   670  		var err error
   671  		var annotatedContext context.Context
   672  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateStringValue", runtime.WithHTTPPathPattern("/v1/testString"))
   673  		if err != nil {
   674  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   675  			return
   676  		}
   677  		resp, md, err := request_WrappersService_CreateStringValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   678  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   679  		if err != nil {
   680  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   681  			return
   682  		}
   683  
   684  		forward_WrappersService_CreateStringValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   685  
   686  	})
   687  
   688  	mux.Handle("POST", pattern_WrappersService_CreateInt32Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   689  		ctx, cancel := context.WithCancel(req.Context())
   690  		defer cancel()
   691  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   692  		var err error
   693  		var annotatedContext context.Context
   694  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateInt32Value", runtime.WithHTTPPathPattern("/v1/testInt32"))
   695  		if err != nil {
   696  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   697  			return
   698  		}
   699  		resp, md, err := request_WrappersService_CreateInt32Value_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   700  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   701  		if err != nil {
   702  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   703  			return
   704  		}
   705  
   706  		forward_WrappersService_CreateInt32Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   707  
   708  	})
   709  
   710  	mux.Handle("POST", pattern_WrappersService_CreateInt64Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   711  		ctx, cancel := context.WithCancel(req.Context())
   712  		defer cancel()
   713  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   714  		var err error
   715  		var annotatedContext context.Context
   716  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateInt64Value", runtime.WithHTTPPathPattern("/v1/testInt64"))
   717  		if err != nil {
   718  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   719  			return
   720  		}
   721  		resp, md, err := request_WrappersService_CreateInt64Value_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   722  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   723  		if err != nil {
   724  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   725  			return
   726  		}
   727  
   728  		forward_WrappersService_CreateInt64Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   729  
   730  	})
   731  
   732  	mux.Handle("POST", pattern_WrappersService_CreateFloatValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   733  		ctx, cancel := context.WithCancel(req.Context())
   734  		defer cancel()
   735  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   736  		var err error
   737  		var annotatedContext context.Context
   738  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateFloatValue", runtime.WithHTTPPathPattern("/v1/testFloat"))
   739  		if err != nil {
   740  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   741  			return
   742  		}
   743  		resp, md, err := request_WrappersService_CreateFloatValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   744  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   745  		if err != nil {
   746  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   747  			return
   748  		}
   749  
   750  		forward_WrappersService_CreateFloatValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   751  
   752  	})
   753  
   754  	mux.Handle("POST", pattern_WrappersService_CreateDoubleValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   755  		ctx, cancel := context.WithCancel(req.Context())
   756  		defer cancel()
   757  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   758  		var err error
   759  		var annotatedContext context.Context
   760  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateDoubleValue", runtime.WithHTTPPathPattern("/v1/testDouble"))
   761  		if err != nil {
   762  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   763  			return
   764  		}
   765  		resp, md, err := request_WrappersService_CreateDoubleValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   766  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   767  		if err != nil {
   768  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   769  			return
   770  		}
   771  
   772  		forward_WrappersService_CreateDoubleValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   773  
   774  	})
   775  
   776  	mux.Handle("POST", pattern_WrappersService_CreateBoolValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   777  		ctx, cancel := context.WithCancel(req.Context())
   778  		defer cancel()
   779  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   780  		var err error
   781  		var annotatedContext context.Context
   782  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateBoolValue", runtime.WithHTTPPathPattern("/v1/testBool"))
   783  		if err != nil {
   784  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   785  			return
   786  		}
   787  		resp, md, err := request_WrappersService_CreateBoolValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   788  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   789  		if err != nil {
   790  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   791  			return
   792  		}
   793  
   794  		forward_WrappersService_CreateBoolValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   795  
   796  	})
   797  
   798  	mux.Handle("POST", pattern_WrappersService_CreateUInt32Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   799  		ctx, cancel := context.WithCancel(req.Context())
   800  		defer cancel()
   801  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   802  		var err error
   803  		var annotatedContext context.Context
   804  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateUInt32Value", runtime.WithHTTPPathPattern("/v1/testUint32"))
   805  		if err != nil {
   806  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   807  			return
   808  		}
   809  		resp, md, err := request_WrappersService_CreateUInt32Value_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   810  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   811  		if err != nil {
   812  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   813  			return
   814  		}
   815  
   816  		forward_WrappersService_CreateUInt32Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   817  
   818  	})
   819  
   820  	mux.Handle("POST", pattern_WrappersService_CreateUInt64Value_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   821  		ctx, cancel := context.WithCancel(req.Context())
   822  		defer cancel()
   823  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   824  		var err error
   825  		var annotatedContext context.Context
   826  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateUInt64Value", runtime.WithHTTPPathPattern("/v1/testUint64"))
   827  		if err != nil {
   828  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   829  			return
   830  		}
   831  		resp, md, err := request_WrappersService_CreateUInt64Value_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   832  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   833  		if err != nil {
   834  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   835  			return
   836  		}
   837  
   838  		forward_WrappersService_CreateUInt64Value_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   839  
   840  	})
   841  
   842  	mux.Handle("POST", pattern_WrappersService_CreateBytesValue_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   843  		ctx, cancel := context.WithCancel(req.Context())
   844  		defer cancel()
   845  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   846  		var err error
   847  		var annotatedContext context.Context
   848  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateBytesValue", runtime.WithHTTPPathPattern("/v1/testBytes"))
   849  		if err != nil {
   850  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   851  			return
   852  		}
   853  		resp, md, err := request_WrappersService_CreateBytesValue_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   854  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   855  		if err != nil {
   856  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   857  			return
   858  		}
   859  
   860  		forward_WrappersService_CreateBytesValue_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   861  
   862  	})
   863  
   864  	mux.Handle("POST", pattern_WrappersService_CreateEmpty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   865  		ctx, cancel := context.WithCancel(req.Context())
   866  		defer cancel()
   867  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   868  		var err error
   869  		var annotatedContext context.Context
   870  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateEmpty", runtime.WithHTTPPathPattern("/v1/testEmpty"))
   871  		if err != nil {
   872  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   873  			return
   874  		}
   875  		resp, md, err := request_WrappersService_CreateEmpty_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   876  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   877  		if err != nil {
   878  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   879  			return
   880  		}
   881  
   882  		forward_WrappersService_CreateEmpty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   883  
   884  	})
   885  
   886  	return nil
   887  }
   888  
   889  var (
   890  	pattern_WrappersService_Create_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "wrappers"}, ""))
   891  
   892  	pattern_WrappersService_CreateStringValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testString"}, ""))
   893  
   894  	pattern_WrappersService_CreateInt32Value_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testInt32"}, ""))
   895  
   896  	pattern_WrappersService_CreateInt64Value_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testInt64"}, ""))
   897  
   898  	pattern_WrappersService_CreateFloatValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testFloat"}, ""))
   899  
   900  	pattern_WrappersService_CreateDoubleValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testDouble"}, ""))
   901  
   902  	pattern_WrappersService_CreateBoolValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testBool"}, ""))
   903  
   904  	pattern_WrappersService_CreateUInt32Value_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testUint32"}, ""))
   905  
   906  	pattern_WrappersService_CreateUInt64Value_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testUint64"}, ""))
   907  
   908  	pattern_WrappersService_CreateBytesValue_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testBytes"}, ""))
   909  
   910  	pattern_WrappersService_CreateEmpty_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "testEmpty"}, ""))
   911  )
   912  
   913  var (
   914  	forward_WrappersService_Create_0 = runtime.ForwardResponseMessage
   915  
   916  	forward_WrappersService_CreateStringValue_0 = runtime.ForwardResponseMessage
   917  
   918  	forward_WrappersService_CreateInt32Value_0 = runtime.ForwardResponseMessage
   919  
   920  	forward_WrappersService_CreateInt64Value_0 = runtime.ForwardResponseMessage
   921  
   922  	forward_WrappersService_CreateFloatValue_0 = runtime.ForwardResponseMessage
   923  
   924  	forward_WrappersService_CreateDoubleValue_0 = runtime.ForwardResponseMessage
   925  
   926  	forward_WrappersService_CreateBoolValue_0 = runtime.ForwardResponseMessage
   927  
   928  	forward_WrappersService_CreateUInt32Value_0 = runtime.ForwardResponseMessage
   929  
   930  	forward_WrappersService_CreateUInt64Value_0 = runtime.ForwardResponseMessage
   931  
   932  	forward_WrappersService_CreateBytesValue_0 = runtime.ForwardResponseMessage
   933  
   934  	forward_WrappersService_CreateEmpty_0 = runtime.ForwardResponseMessage
   935  )
   936  

View as plain text