1
2
3
4
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
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
413
414
415
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
675
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
700
701 func RegisterWrappersServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
702 return RegisterWrappersServiceHandlerClient(ctx, mux, NewWrappersServiceClient(conn))
703 }
704
705
706
707
708
709
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