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

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

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

View as plain text