github.com/grpc-ecosystem/grpc-gateway/v2@v2.19.1/examples/internal/proto/examplepb/a_bit_of_everything.pb.gw.go (about) 1 // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. 2 // source: examples/internal/proto/examplepb/a_bit_of_everything.proto 3 4 /* 5 Package examplepb is a reverse proxy. 6 7 It translates gRPC into RESTful JSON APIs. 8 */ 9 package examplepb 10 11 import ( 12 "context" 13 "io" 14 "net/http" 15 16 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/oneofenum" 17 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/pathenum" 18 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/sub" 19 "github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/sub2" 20 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" 21 "github.com/grpc-ecosystem/grpc-gateway/v2/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 "google.golang.org/protobuf/proto" 28 "google.golang.org/protobuf/types/known/emptypb" 29 ) 30 31 // Suppress "imported and not used" errors 32 var _ codes.Code 33 var _ io.Reader 34 var _ status.Status 35 var _ = runtime.String 36 var _ = utilities.NewDoubleArray 37 var _ = metadata.Join 38 39 var ( 40 filter_ABitOfEverythingService_Create_0 = &utilities.DoubleArray{Encoding: map[string]int{"float_value": 0, "double_value": 1, "int64_value": 2, "uint64_value": 3, "int32_value": 4, "fixed64_value": 5, "fixed32_value": 6, "bool_value": 7, "string_value": 8, "uint32_value": 9, "sfixed32_value": 10, "sfixed64_value": 11, "sint32_value": 12, "sint64_value": 13, "nonConventionalNameValue": 14, "enum_value": 15, "path_enum_value": 16, "nested_path_enum_value": 17, "enum_value_annotation": 18}, Base: []int{1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}} 41 ) 42 43 func request_ABitOfEverythingService_Create_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 44 var protoReq ABitOfEverything 45 var metadata runtime.ServerMetadata 46 47 var ( 48 val string 49 e int32 50 ok bool 51 err error 52 _ = err 53 ) 54 55 val, ok = pathParams["float_value"] 56 if !ok { 57 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "float_value") 58 } 59 60 protoReq.FloatValue, err = runtime.Float32(val) 61 if err != nil { 62 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "float_value", err) 63 } 64 65 val, ok = pathParams["double_value"] 66 if !ok { 67 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "double_value") 68 } 69 70 protoReq.DoubleValue, err = runtime.Float64(val) 71 if err != nil { 72 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "double_value", err) 73 } 74 75 val, ok = pathParams["int64_value"] 76 if !ok { 77 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64_value") 78 } 79 80 protoReq.Int64Value, err = runtime.Int64(val) 81 if err != nil { 82 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64_value", err) 83 } 84 85 val, ok = pathParams["uint64_value"] 86 if !ok { 87 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64_value") 88 } 89 90 protoReq.Uint64Value, err = runtime.Uint64(val) 91 if err != nil { 92 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64_value", err) 93 } 94 95 val, ok = pathParams["int32_value"] 96 if !ok { 97 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32_value") 98 } 99 100 protoReq.Int32Value, err = runtime.Int32(val) 101 if err != nil { 102 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32_value", err) 103 } 104 105 val, ok = pathParams["fixed64_value"] 106 if !ok { 107 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed64_value") 108 } 109 110 protoReq.Fixed64Value, err = runtime.Uint64(val) 111 if err != nil { 112 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed64_value", err) 113 } 114 115 val, ok = pathParams["fixed32_value"] 116 if !ok { 117 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed32_value") 118 } 119 120 protoReq.Fixed32Value, err = runtime.Uint32(val) 121 if err != nil { 122 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed32_value", err) 123 } 124 125 val, ok = pathParams["bool_value"] 126 if !ok { 127 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bool_value") 128 } 129 130 protoReq.BoolValue, err = runtime.Bool(val) 131 if err != nil { 132 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bool_value", err) 133 } 134 135 val, ok = pathParams["string_value"] 136 if !ok { 137 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value") 138 } 139 140 protoReq.StringValue, err = runtime.String(val) 141 if err != nil { 142 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err) 143 } 144 145 val, ok = pathParams["uint32_value"] 146 if !ok { 147 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32_value") 148 } 149 150 protoReq.Uint32Value, err = runtime.Uint32(val) 151 if err != nil { 152 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32_value", err) 153 } 154 155 val, ok = pathParams["sfixed32_value"] 156 if !ok { 157 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed32_value") 158 } 159 160 protoReq.Sfixed32Value, err = runtime.Int32(val) 161 if err != nil { 162 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed32_value", err) 163 } 164 165 val, ok = pathParams["sfixed64_value"] 166 if !ok { 167 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed64_value") 168 } 169 170 protoReq.Sfixed64Value, err = runtime.Int64(val) 171 if err != nil { 172 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed64_value", err) 173 } 174 175 val, ok = pathParams["sint32_value"] 176 if !ok { 177 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint32_value") 178 } 179 180 protoReq.Sint32Value, err = runtime.Int32(val) 181 if err != nil { 182 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint32_value", err) 183 } 184 185 val, ok = pathParams["sint64_value"] 186 if !ok { 187 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint64_value") 188 } 189 190 protoReq.Sint64Value, err = runtime.Int64(val) 191 if err != nil { 192 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint64_value", err) 193 } 194 195 val, ok = pathParams["nonConventionalNameValue"] 196 if !ok { 197 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nonConventionalNameValue") 198 } 199 200 protoReq.NonConventionalNameValue, err = runtime.String(val) 201 if err != nil { 202 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nonConventionalNameValue", err) 203 } 204 205 val, ok = pathParams["enum_value"] 206 if !ok { 207 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value") 208 } 209 210 e, err = runtime.Enum(val, NumericEnum_value) 211 if err != nil { 212 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value", err) 213 } 214 215 protoReq.EnumValue = NumericEnum(e) 216 217 val, ok = pathParams["path_enum_value"] 218 if !ok { 219 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_enum_value") 220 } 221 222 e, err = runtime.Enum(val, pathenum.PathEnum_value) 223 if err != nil { 224 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_enum_value", err) 225 } 226 227 protoReq.PathEnumValue = pathenum.PathEnum(e) 228 229 val, ok = pathParams["nested_path_enum_value"] 230 if !ok { 231 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nested_path_enum_value") 232 } 233 234 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value) 235 if err != nil { 236 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nested_path_enum_value", err) 237 } 238 239 protoReq.NestedPathEnumValue = pathenum.MessagePathEnum_NestedPathEnum(e) 240 241 val, ok = pathParams["enum_value_annotation"] 242 if !ok { 243 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value_annotation") 244 } 245 246 e, err = runtime.Enum(val, NumericEnum_value) 247 if err != nil { 248 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value_annotation", err) 249 } 250 251 protoReq.EnumValueAnnotation = NumericEnum(e) 252 253 if err := req.ParseForm(); err != nil { 254 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 255 } 256 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Create_0); err != nil { 257 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 258 } 259 260 msg, err := client.Create(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 261 return msg, metadata, err 262 263 } 264 265 func local_request_ABitOfEverythingService_Create_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 266 var protoReq ABitOfEverything 267 var metadata runtime.ServerMetadata 268 269 var ( 270 val string 271 e int32 272 ok bool 273 err error 274 _ = err 275 ) 276 277 val, ok = pathParams["float_value"] 278 if !ok { 279 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "float_value") 280 } 281 282 protoReq.FloatValue, err = runtime.Float32(val) 283 if err != nil { 284 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "float_value", err) 285 } 286 287 val, ok = pathParams["double_value"] 288 if !ok { 289 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "double_value") 290 } 291 292 protoReq.DoubleValue, err = runtime.Float64(val) 293 if err != nil { 294 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "double_value", err) 295 } 296 297 val, ok = pathParams["int64_value"] 298 if !ok { 299 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int64_value") 300 } 301 302 protoReq.Int64Value, err = runtime.Int64(val) 303 if err != nil { 304 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int64_value", err) 305 } 306 307 val, ok = pathParams["uint64_value"] 308 if !ok { 309 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint64_value") 310 } 311 312 protoReq.Uint64Value, err = runtime.Uint64(val) 313 if err != nil { 314 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint64_value", err) 315 } 316 317 val, ok = pathParams["int32_value"] 318 if !ok { 319 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "int32_value") 320 } 321 322 protoReq.Int32Value, err = runtime.Int32(val) 323 if err != nil { 324 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "int32_value", err) 325 } 326 327 val, ok = pathParams["fixed64_value"] 328 if !ok { 329 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed64_value") 330 } 331 332 protoReq.Fixed64Value, err = runtime.Uint64(val) 333 if err != nil { 334 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed64_value", err) 335 } 336 337 val, ok = pathParams["fixed32_value"] 338 if !ok { 339 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "fixed32_value") 340 } 341 342 protoReq.Fixed32Value, err = runtime.Uint32(val) 343 if err != nil { 344 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "fixed32_value", err) 345 } 346 347 val, ok = pathParams["bool_value"] 348 if !ok { 349 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bool_value") 350 } 351 352 protoReq.BoolValue, err = runtime.Bool(val) 353 if err != nil { 354 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bool_value", err) 355 } 356 357 val, ok = pathParams["string_value"] 358 if !ok { 359 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value") 360 } 361 362 protoReq.StringValue, err = runtime.String(val) 363 if err != nil { 364 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err) 365 } 366 367 val, ok = pathParams["uint32_value"] 368 if !ok { 369 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uint32_value") 370 } 371 372 protoReq.Uint32Value, err = runtime.Uint32(val) 373 if err != nil { 374 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uint32_value", err) 375 } 376 377 val, ok = pathParams["sfixed32_value"] 378 if !ok { 379 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed32_value") 380 } 381 382 protoReq.Sfixed32Value, err = runtime.Int32(val) 383 if err != nil { 384 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed32_value", err) 385 } 386 387 val, ok = pathParams["sfixed64_value"] 388 if !ok { 389 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sfixed64_value") 390 } 391 392 protoReq.Sfixed64Value, err = runtime.Int64(val) 393 if err != nil { 394 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sfixed64_value", err) 395 } 396 397 val, ok = pathParams["sint32_value"] 398 if !ok { 399 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint32_value") 400 } 401 402 protoReq.Sint32Value, err = runtime.Int32(val) 403 if err != nil { 404 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint32_value", err) 405 } 406 407 val, ok = pathParams["sint64_value"] 408 if !ok { 409 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "sint64_value") 410 } 411 412 protoReq.Sint64Value, err = runtime.Int64(val) 413 if err != nil { 414 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "sint64_value", err) 415 } 416 417 val, ok = pathParams["nonConventionalNameValue"] 418 if !ok { 419 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nonConventionalNameValue") 420 } 421 422 protoReq.NonConventionalNameValue, err = runtime.String(val) 423 if err != nil { 424 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nonConventionalNameValue", err) 425 } 426 427 val, ok = pathParams["enum_value"] 428 if !ok { 429 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value") 430 } 431 432 e, err = runtime.Enum(val, NumericEnum_value) 433 if err != nil { 434 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value", err) 435 } 436 437 protoReq.EnumValue = NumericEnum(e) 438 439 val, ok = pathParams["path_enum_value"] 440 if !ok { 441 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_enum_value") 442 } 443 444 e, err = runtime.Enum(val, pathenum.PathEnum_value) 445 if err != nil { 446 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_enum_value", err) 447 } 448 449 protoReq.PathEnumValue = pathenum.PathEnum(e) 450 451 val, ok = pathParams["nested_path_enum_value"] 452 if !ok { 453 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "nested_path_enum_value") 454 } 455 456 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value) 457 if err != nil { 458 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "nested_path_enum_value", err) 459 } 460 461 protoReq.NestedPathEnumValue = pathenum.MessagePathEnum_NestedPathEnum(e) 462 463 val, ok = pathParams["enum_value_annotation"] 464 if !ok { 465 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "enum_value_annotation") 466 } 467 468 e, err = runtime.Enum(val, NumericEnum_value) 469 if err != nil { 470 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "enum_value_annotation", err) 471 } 472 473 protoReq.EnumValueAnnotation = NumericEnum(e) 474 475 if err := req.ParseForm(); err != nil { 476 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 477 } 478 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Create_0); err != nil { 479 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 480 } 481 482 msg, err := server.Create(ctx, &protoReq) 483 return msg, metadata, err 484 485 } 486 487 func request_ABitOfEverythingService_CreateBody_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 488 var protoReq ABitOfEverything 489 var metadata runtime.ServerMetadata 490 491 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 492 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 493 } 494 495 msg, err := client.CreateBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 496 return msg, metadata, err 497 498 } 499 500 func local_request_ABitOfEverythingService_CreateBody_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 501 var protoReq ABitOfEverything 502 var metadata runtime.ServerMetadata 503 504 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 505 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 506 } 507 508 msg, err := server.CreateBody(ctx, &protoReq) 509 return msg, metadata, err 510 511 } 512 513 var ( 514 filter_ABitOfEverythingService_CreateBook_0 = &utilities.DoubleArray{Encoding: map[string]int{"book": 0, "parent": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}} 515 ) 516 517 func request_ABitOfEverythingService_CreateBook_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 518 var protoReq CreateBookRequest 519 var metadata runtime.ServerMetadata 520 521 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Book); err != nil && err != io.EOF { 522 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 523 } 524 525 var ( 526 val string 527 ok bool 528 err error 529 _ = err 530 ) 531 532 val, ok = pathParams["parent"] 533 if !ok { 534 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent") 535 } 536 537 protoReq.Parent, err = runtime.String(val) 538 if err != nil { 539 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err) 540 } 541 542 if err := req.ParseForm(); err != nil { 543 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 544 } 545 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CreateBook_0); err != nil { 546 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 547 } 548 549 msg, err := client.CreateBook(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 550 return msg, metadata, err 551 552 } 553 554 func local_request_ABitOfEverythingService_CreateBook_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 555 var protoReq CreateBookRequest 556 var metadata runtime.ServerMetadata 557 558 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Book); err != nil && err != io.EOF { 559 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 560 } 561 562 var ( 563 val string 564 ok bool 565 err error 566 _ = err 567 ) 568 569 val, ok = pathParams["parent"] 570 if !ok { 571 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent") 572 } 573 574 protoReq.Parent, err = runtime.String(val) 575 if err != nil { 576 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err) 577 } 578 579 if err := req.ParseForm(); err != nil { 580 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 581 } 582 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CreateBook_0); err != nil { 583 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 584 } 585 586 msg, err := server.CreateBook(ctx, &protoReq) 587 return msg, metadata, err 588 589 } 590 591 var ( 592 filter_ABitOfEverythingService_UpdateBook_0 = &utilities.DoubleArray{Encoding: map[string]int{"book": 0, "name": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}} 593 ) 594 595 func request_ABitOfEverythingService_UpdateBook_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 596 var protoReq UpdateBookRequest 597 var metadata runtime.ServerMetadata 598 599 newReader, berr := utilities.IOReaderFactory(req.Body) 600 if berr != nil { 601 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 602 } 603 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Book); err != nil && err != io.EOF { 604 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 605 } 606 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { 607 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Book); err != nil { 608 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 609 } else { 610 protoReq.UpdateMask = fieldMask 611 } 612 } 613 614 var ( 615 val string 616 ok bool 617 err error 618 _ = err 619 ) 620 621 val, ok = pathParams["book.name"] 622 if !ok { 623 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "book.name") 624 } 625 626 err = runtime.PopulateFieldFromPath(&protoReq, "book.name", val) 627 if err != nil { 628 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "book.name", err) 629 } 630 631 if err := req.ParseForm(); err != nil { 632 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 633 } 634 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateBook_0); err != nil { 635 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 636 } 637 638 msg, err := client.UpdateBook(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 639 return msg, metadata, err 640 641 } 642 643 func local_request_ABitOfEverythingService_UpdateBook_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 644 var protoReq UpdateBookRequest 645 var metadata runtime.ServerMetadata 646 647 newReader, berr := utilities.IOReaderFactory(req.Body) 648 if berr != nil { 649 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 650 } 651 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Book); err != nil && err != io.EOF { 652 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 653 } 654 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { 655 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Book); err != nil { 656 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 657 } else { 658 protoReq.UpdateMask = fieldMask 659 } 660 } 661 662 var ( 663 val string 664 ok bool 665 err error 666 _ = err 667 ) 668 669 val, ok = pathParams["book.name"] 670 if !ok { 671 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "book.name") 672 } 673 674 err = runtime.PopulateFieldFromPath(&protoReq, "book.name", val) 675 if err != nil { 676 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "book.name", err) 677 } 678 679 if err := req.ParseForm(); err != nil { 680 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 681 } 682 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateBook_0); err != nil { 683 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 684 } 685 686 msg, err := server.UpdateBook(ctx, &protoReq) 687 return msg, metadata, err 688 689 } 690 691 func request_ABitOfEverythingService_Lookup_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 692 var protoReq sub2.IdMessage 693 var metadata runtime.ServerMetadata 694 695 var ( 696 val string 697 ok bool 698 err error 699 _ = err 700 ) 701 702 val, ok = pathParams["uuid"] 703 if !ok { 704 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 705 } 706 707 protoReq.Uuid, err = runtime.String(val) 708 if err != nil { 709 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 710 } 711 712 msg, err := client.Lookup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 713 return msg, metadata, err 714 715 } 716 717 func local_request_ABitOfEverythingService_Lookup_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 718 var protoReq sub2.IdMessage 719 var metadata runtime.ServerMetadata 720 721 var ( 722 val string 723 ok bool 724 err error 725 _ = err 726 ) 727 728 val, ok = pathParams["uuid"] 729 if !ok { 730 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 731 } 732 733 protoReq.Uuid, err = runtime.String(val) 734 if err != nil { 735 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 736 } 737 738 msg, err := server.Lookup(ctx, &protoReq) 739 return msg, metadata, err 740 741 } 742 743 var ( 744 filter_ABitOfEverythingService_Custom_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 745 ) 746 747 func request_ABitOfEverythingService_Custom_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 748 var protoReq ABitOfEverything 749 var metadata runtime.ServerMetadata 750 751 var ( 752 val string 753 ok bool 754 err error 755 _ = err 756 ) 757 758 val, ok = pathParams["uuid"] 759 if !ok { 760 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 761 } 762 763 protoReq.Uuid, err = runtime.String(val) 764 if err != nil { 765 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 766 } 767 768 if err := req.ParseForm(); err != nil { 769 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 770 } 771 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Custom_0); err != nil { 772 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 773 } 774 775 msg, err := client.Custom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 776 return msg, metadata, err 777 778 } 779 780 func local_request_ABitOfEverythingService_Custom_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 781 var protoReq ABitOfEverything 782 var metadata runtime.ServerMetadata 783 784 var ( 785 val string 786 ok bool 787 err error 788 _ = err 789 ) 790 791 val, ok = pathParams["uuid"] 792 if !ok { 793 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 794 } 795 796 protoReq.Uuid, err = runtime.String(val) 797 if err != nil { 798 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 799 } 800 801 if err := req.ParseForm(); err != nil { 802 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 803 } 804 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Custom_0); err != nil { 805 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 806 } 807 808 msg, err := server.Custom(ctx, &protoReq) 809 return msg, metadata, err 810 811 } 812 813 var ( 814 filter_ABitOfEverythingService_DoubleColon_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 815 ) 816 817 func request_ABitOfEverythingService_DoubleColon_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 818 var protoReq ABitOfEverything 819 var metadata runtime.ServerMetadata 820 821 var ( 822 val string 823 ok bool 824 err error 825 _ = err 826 ) 827 828 val, ok = pathParams["uuid"] 829 if !ok { 830 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 831 } 832 833 protoReq.Uuid, err = runtime.String(val) 834 if err != nil { 835 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 836 } 837 838 if err := req.ParseForm(); err != nil { 839 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 840 } 841 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_DoubleColon_0); err != nil { 842 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 843 } 844 845 msg, err := client.DoubleColon(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 846 return msg, metadata, err 847 848 } 849 850 func local_request_ABitOfEverythingService_DoubleColon_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 851 var protoReq ABitOfEverything 852 var metadata runtime.ServerMetadata 853 854 var ( 855 val string 856 ok bool 857 err error 858 _ = err 859 ) 860 861 val, ok = pathParams["uuid"] 862 if !ok { 863 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 864 } 865 866 protoReq.Uuid, err = runtime.String(val) 867 if err != nil { 868 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 869 } 870 871 if err := req.ParseForm(); err != nil { 872 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 873 } 874 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_DoubleColon_0); err != nil { 875 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 876 } 877 878 msg, err := server.DoubleColon(ctx, &protoReq) 879 return msg, metadata, err 880 881 } 882 883 func request_ABitOfEverythingService_Update_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 884 var protoReq ABitOfEverything 885 var metadata runtime.ServerMetadata 886 887 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 888 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 889 } 890 891 var ( 892 val string 893 ok bool 894 err error 895 _ = err 896 ) 897 898 val, ok = pathParams["uuid"] 899 if !ok { 900 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 901 } 902 903 protoReq.Uuid, err = runtime.String(val) 904 if err != nil { 905 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 906 } 907 908 msg, err := client.Update(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 909 return msg, metadata, err 910 911 } 912 913 func local_request_ABitOfEverythingService_Update_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 914 var protoReq ABitOfEverything 915 var metadata runtime.ServerMetadata 916 917 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 918 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 919 } 920 921 var ( 922 val string 923 ok bool 924 err error 925 _ = err 926 ) 927 928 val, ok = pathParams["uuid"] 929 if !ok { 930 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 931 } 932 933 protoReq.Uuid, err = runtime.String(val) 934 if err != nil { 935 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 936 } 937 938 msg, err := server.Update(ctx, &protoReq) 939 return msg, metadata, err 940 941 } 942 943 var ( 944 filter_ABitOfEverythingService_UpdateV2_0 = &utilities.DoubleArray{Encoding: map[string]int{"abe": 0, "uuid": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}} 945 ) 946 947 func request_ABitOfEverythingService_UpdateV2_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 948 var protoReq UpdateV2Request 949 var metadata runtime.ServerMetadata 950 951 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Abe); err != nil && err != io.EOF { 952 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 953 } 954 955 var ( 956 val string 957 ok bool 958 err error 959 _ = err 960 ) 961 962 val, ok = pathParams["abe.uuid"] 963 if !ok { 964 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid") 965 } 966 967 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val) 968 if err != nil { 969 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err) 970 } 971 972 if err := req.ParseForm(); err != nil { 973 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 974 } 975 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_0); err != nil { 976 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 977 } 978 979 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 980 return msg, metadata, err 981 982 } 983 984 func local_request_ABitOfEverythingService_UpdateV2_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 985 var protoReq UpdateV2Request 986 var metadata runtime.ServerMetadata 987 988 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Abe); err != nil && err != io.EOF { 989 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 990 } 991 992 var ( 993 val string 994 ok bool 995 err error 996 _ = err 997 ) 998 999 val, ok = pathParams["abe.uuid"] 1000 if !ok { 1001 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid") 1002 } 1003 1004 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val) 1005 if err != nil { 1006 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err) 1007 } 1008 1009 if err := req.ParseForm(); err != nil { 1010 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1011 } 1012 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_0); err != nil { 1013 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1014 } 1015 1016 msg, err := server.UpdateV2(ctx, &protoReq) 1017 return msg, metadata, err 1018 1019 } 1020 1021 var ( 1022 filter_ABitOfEverythingService_UpdateV2_1 = &utilities.DoubleArray{Encoding: map[string]int{"abe": 0, "uuid": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}} 1023 ) 1024 1025 func request_ABitOfEverythingService_UpdateV2_1(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1026 var protoReq UpdateV2Request 1027 var metadata runtime.ServerMetadata 1028 1029 newReader, berr := utilities.IOReaderFactory(req.Body) 1030 if berr != nil { 1031 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 1032 } 1033 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF { 1034 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1035 } 1036 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { 1037 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Abe); err != nil { 1038 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1039 } else { 1040 protoReq.UpdateMask = fieldMask 1041 } 1042 } 1043 1044 var ( 1045 val string 1046 ok bool 1047 err error 1048 _ = err 1049 ) 1050 1051 val, ok = pathParams["abe.uuid"] 1052 if !ok { 1053 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid") 1054 } 1055 1056 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val) 1057 if err != nil { 1058 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err) 1059 } 1060 1061 if err := req.ParseForm(); err != nil { 1062 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1063 } 1064 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_1); err != nil { 1065 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1066 } 1067 1068 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1069 return msg, metadata, err 1070 1071 } 1072 1073 func local_request_ABitOfEverythingService_UpdateV2_1(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1074 var protoReq UpdateV2Request 1075 var metadata runtime.ServerMetadata 1076 1077 newReader, berr := utilities.IOReaderFactory(req.Body) 1078 if berr != nil { 1079 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 1080 } 1081 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Abe); err != nil && err != io.EOF { 1082 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1083 } 1084 if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { 1085 if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Abe); err != nil { 1086 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1087 } else { 1088 protoReq.UpdateMask = fieldMask 1089 } 1090 } 1091 1092 var ( 1093 val string 1094 ok bool 1095 err error 1096 _ = err 1097 ) 1098 1099 val, ok = pathParams["abe.uuid"] 1100 if !ok { 1101 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid") 1102 } 1103 1104 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val) 1105 if err != nil { 1106 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err) 1107 } 1108 1109 if err := req.ParseForm(); err != nil { 1110 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1111 } 1112 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_UpdateV2_1); err != nil { 1113 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1114 } 1115 1116 msg, err := server.UpdateV2(ctx, &protoReq) 1117 return msg, metadata, err 1118 1119 } 1120 1121 func request_ABitOfEverythingService_UpdateV2_2(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1122 var protoReq UpdateV2Request 1123 var metadata runtime.ServerMetadata 1124 1125 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 1126 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1127 } 1128 1129 var ( 1130 val string 1131 ok bool 1132 err error 1133 _ = err 1134 ) 1135 1136 val, ok = pathParams["abe.uuid"] 1137 if !ok { 1138 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid") 1139 } 1140 1141 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val) 1142 if err != nil { 1143 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err) 1144 } 1145 1146 msg, err := client.UpdateV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1147 return msg, metadata, err 1148 1149 } 1150 1151 func local_request_ABitOfEverythingService_UpdateV2_2(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1152 var protoReq UpdateV2Request 1153 var metadata runtime.ServerMetadata 1154 1155 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 1156 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1157 } 1158 1159 var ( 1160 val string 1161 ok bool 1162 err error 1163 _ = err 1164 ) 1165 1166 val, ok = pathParams["abe.uuid"] 1167 if !ok { 1168 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "abe.uuid") 1169 } 1170 1171 err = runtime.PopulateFieldFromPath(&protoReq, "abe.uuid", val) 1172 if err != nil { 1173 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "abe.uuid", err) 1174 } 1175 1176 msg, err := server.UpdateV2(ctx, &protoReq) 1177 return msg, metadata, err 1178 1179 } 1180 1181 func request_ABitOfEverythingService_Delete_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1182 var protoReq sub2.IdMessage 1183 var metadata runtime.ServerMetadata 1184 1185 var ( 1186 val string 1187 ok bool 1188 err error 1189 _ = err 1190 ) 1191 1192 val, ok = pathParams["uuid"] 1193 if !ok { 1194 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 1195 } 1196 1197 protoReq.Uuid, err = runtime.String(val) 1198 if err != nil { 1199 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 1200 } 1201 1202 msg, err := client.Delete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1203 return msg, metadata, err 1204 1205 } 1206 1207 func local_request_ABitOfEverythingService_Delete_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1208 var protoReq sub2.IdMessage 1209 var metadata runtime.ServerMetadata 1210 1211 var ( 1212 val string 1213 ok bool 1214 err error 1215 _ = err 1216 ) 1217 1218 val, ok = pathParams["uuid"] 1219 if !ok { 1220 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 1221 } 1222 1223 protoReq.Uuid, err = runtime.String(val) 1224 if err != nil { 1225 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 1226 } 1227 1228 msg, err := server.Delete(ctx, &protoReq) 1229 return msg, metadata, err 1230 1231 } 1232 1233 var ( 1234 filter_ABitOfEverythingService_GetQuery_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 1235 ) 1236 1237 func request_ABitOfEverythingService_GetQuery_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1238 var protoReq ABitOfEverything 1239 var metadata runtime.ServerMetadata 1240 1241 var ( 1242 val string 1243 ok bool 1244 err error 1245 _ = err 1246 ) 1247 1248 val, ok = pathParams["uuid"] 1249 if !ok { 1250 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 1251 } 1252 1253 protoReq.Uuid, err = runtime.String(val) 1254 if err != nil { 1255 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 1256 } 1257 1258 if err := req.ParseForm(); err != nil { 1259 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1260 } 1261 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_GetQuery_0); err != nil { 1262 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1263 } 1264 1265 msg, err := client.GetQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1266 return msg, metadata, err 1267 1268 } 1269 1270 func local_request_ABitOfEverythingService_GetQuery_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1271 var protoReq ABitOfEverything 1272 var metadata runtime.ServerMetadata 1273 1274 var ( 1275 val string 1276 ok bool 1277 err error 1278 _ = err 1279 ) 1280 1281 val, ok = pathParams["uuid"] 1282 if !ok { 1283 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 1284 } 1285 1286 protoReq.Uuid, err = runtime.String(val) 1287 if err != nil { 1288 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 1289 } 1290 1291 if err := req.ParseForm(); err != nil { 1292 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1293 } 1294 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_GetQuery_0); err != nil { 1295 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1296 } 1297 1298 msg, err := server.GetQuery(ctx, &protoReq) 1299 return msg, metadata, err 1300 1301 } 1302 1303 func request_ABitOfEverythingService_GetRepeatedQuery_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1304 var protoReq ABitOfEverythingRepeated 1305 var metadata runtime.ServerMetadata 1306 1307 var ( 1308 val string 1309 es []int32 1310 ok bool 1311 err error 1312 _ = err 1313 ) 1314 1315 val, ok = pathParams["path_repeated_float_value"] 1316 if !ok { 1317 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_float_value") 1318 } 1319 1320 protoReq.PathRepeatedFloatValue, err = runtime.Float32Slice(val, ",") 1321 if err != nil { 1322 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_float_value", err) 1323 } 1324 1325 val, ok = pathParams["path_repeated_double_value"] 1326 if !ok { 1327 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_double_value") 1328 } 1329 1330 protoReq.PathRepeatedDoubleValue, err = runtime.Float64Slice(val, ",") 1331 if err != nil { 1332 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_double_value", err) 1333 } 1334 1335 val, ok = pathParams["path_repeated_int64_value"] 1336 if !ok { 1337 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int64_value") 1338 } 1339 1340 protoReq.PathRepeatedInt64Value, err = runtime.Int64Slice(val, ",") 1341 if err != nil { 1342 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int64_value", err) 1343 } 1344 1345 val, ok = pathParams["path_repeated_uint64_value"] 1346 if !ok { 1347 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint64_value") 1348 } 1349 1350 protoReq.PathRepeatedUint64Value, err = runtime.Uint64Slice(val, ",") 1351 if err != nil { 1352 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint64_value", err) 1353 } 1354 1355 val, ok = pathParams["path_repeated_int32_value"] 1356 if !ok { 1357 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int32_value") 1358 } 1359 1360 protoReq.PathRepeatedInt32Value, err = runtime.Int32Slice(val, ",") 1361 if err != nil { 1362 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int32_value", err) 1363 } 1364 1365 val, ok = pathParams["path_repeated_fixed64_value"] 1366 if !ok { 1367 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed64_value") 1368 } 1369 1370 protoReq.PathRepeatedFixed64Value, err = runtime.Uint64Slice(val, ",") 1371 if err != nil { 1372 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed64_value", err) 1373 } 1374 1375 val, ok = pathParams["path_repeated_fixed32_value"] 1376 if !ok { 1377 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed32_value") 1378 } 1379 1380 protoReq.PathRepeatedFixed32Value, err = runtime.Uint32Slice(val, ",") 1381 if err != nil { 1382 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed32_value", err) 1383 } 1384 1385 val, ok = pathParams["path_repeated_bool_value"] 1386 if !ok { 1387 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bool_value") 1388 } 1389 1390 protoReq.PathRepeatedBoolValue, err = runtime.BoolSlice(val, ",") 1391 if err != nil { 1392 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bool_value", err) 1393 } 1394 1395 val, ok = pathParams["path_repeated_string_value"] 1396 if !ok { 1397 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_string_value") 1398 } 1399 1400 protoReq.PathRepeatedStringValue, err = runtime.StringSlice(val, ",") 1401 if err != nil { 1402 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_string_value", err) 1403 } 1404 1405 val, ok = pathParams["path_repeated_bytes_value"] 1406 if !ok { 1407 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bytes_value") 1408 } 1409 1410 protoReq.PathRepeatedBytesValue, err = runtime.BytesSlice(val, ",") 1411 if err != nil { 1412 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bytes_value", err) 1413 } 1414 1415 val, ok = pathParams["path_repeated_uint32_value"] 1416 if !ok { 1417 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint32_value") 1418 } 1419 1420 protoReq.PathRepeatedUint32Value, err = runtime.Uint32Slice(val, ",") 1421 if err != nil { 1422 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint32_value", err) 1423 } 1424 1425 val, ok = pathParams["path_repeated_enum_value"] 1426 if !ok { 1427 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_enum_value") 1428 } 1429 1430 es, err = runtime.EnumSlice(val, ",", NumericEnum_value) 1431 if err != nil { 1432 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_enum_value", err) 1433 } 1434 1435 s := make([]NumericEnum, len(es)) 1436 for i, v := range es { 1437 s[i] = NumericEnum(v) 1438 } 1439 protoReq.PathRepeatedEnumValue = s 1440 1441 val, ok = pathParams["path_repeated_sfixed32_value"] 1442 if !ok { 1443 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed32_value") 1444 } 1445 1446 protoReq.PathRepeatedSfixed32Value, err = runtime.Int32Slice(val, ",") 1447 if err != nil { 1448 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed32_value", err) 1449 } 1450 1451 val, ok = pathParams["path_repeated_sfixed64_value"] 1452 if !ok { 1453 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed64_value") 1454 } 1455 1456 protoReq.PathRepeatedSfixed64Value, err = runtime.Int64Slice(val, ",") 1457 if err != nil { 1458 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed64_value", err) 1459 } 1460 1461 val, ok = pathParams["path_repeated_sint32_value"] 1462 if !ok { 1463 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint32_value") 1464 } 1465 1466 protoReq.PathRepeatedSint32Value, err = runtime.Int32Slice(val, ",") 1467 if err != nil { 1468 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint32_value", err) 1469 } 1470 1471 val, ok = pathParams["path_repeated_sint64_value"] 1472 if !ok { 1473 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint64_value") 1474 } 1475 1476 protoReq.PathRepeatedSint64Value, err = runtime.Int64Slice(val, ",") 1477 if err != nil { 1478 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint64_value", err) 1479 } 1480 1481 msg, err := client.GetRepeatedQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1482 return msg, metadata, err 1483 1484 } 1485 1486 func local_request_ABitOfEverythingService_GetRepeatedQuery_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1487 var protoReq ABitOfEverythingRepeated 1488 var metadata runtime.ServerMetadata 1489 1490 var ( 1491 val string 1492 es []int32 1493 ok bool 1494 err error 1495 _ = err 1496 ) 1497 1498 val, ok = pathParams["path_repeated_float_value"] 1499 if !ok { 1500 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_float_value") 1501 } 1502 1503 protoReq.PathRepeatedFloatValue, err = runtime.Float32Slice(val, ",") 1504 if err != nil { 1505 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_float_value", err) 1506 } 1507 1508 val, ok = pathParams["path_repeated_double_value"] 1509 if !ok { 1510 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_double_value") 1511 } 1512 1513 protoReq.PathRepeatedDoubleValue, err = runtime.Float64Slice(val, ",") 1514 if err != nil { 1515 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_double_value", err) 1516 } 1517 1518 val, ok = pathParams["path_repeated_int64_value"] 1519 if !ok { 1520 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int64_value") 1521 } 1522 1523 protoReq.PathRepeatedInt64Value, err = runtime.Int64Slice(val, ",") 1524 if err != nil { 1525 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int64_value", err) 1526 } 1527 1528 val, ok = pathParams["path_repeated_uint64_value"] 1529 if !ok { 1530 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint64_value") 1531 } 1532 1533 protoReq.PathRepeatedUint64Value, err = runtime.Uint64Slice(val, ",") 1534 if err != nil { 1535 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint64_value", err) 1536 } 1537 1538 val, ok = pathParams["path_repeated_int32_value"] 1539 if !ok { 1540 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_int32_value") 1541 } 1542 1543 protoReq.PathRepeatedInt32Value, err = runtime.Int32Slice(val, ",") 1544 if err != nil { 1545 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_int32_value", err) 1546 } 1547 1548 val, ok = pathParams["path_repeated_fixed64_value"] 1549 if !ok { 1550 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed64_value") 1551 } 1552 1553 protoReq.PathRepeatedFixed64Value, err = runtime.Uint64Slice(val, ",") 1554 if err != nil { 1555 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed64_value", err) 1556 } 1557 1558 val, ok = pathParams["path_repeated_fixed32_value"] 1559 if !ok { 1560 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_fixed32_value") 1561 } 1562 1563 protoReq.PathRepeatedFixed32Value, err = runtime.Uint32Slice(val, ",") 1564 if err != nil { 1565 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_fixed32_value", err) 1566 } 1567 1568 val, ok = pathParams["path_repeated_bool_value"] 1569 if !ok { 1570 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bool_value") 1571 } 1572 1573 protoReq.PathRepeatedBoolValue, err = runtime.BoolSlice(val, ",") 1574 if err != nil { 1575 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bool_value", err) 1576 } 1577 1578 val, ok = pathParams["path_repeated_string_value"] 1579 if !ok { 1580 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_string_value") 1581 } 1582 1583 protoReq.PathRepeatedStringValue, err = runtime.StringSlice(val, ",") 1584 if err != nil { 1585 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_string_value", err) 1586 } 1587 1588 val, ok = pathParams["path_repeated_bytes_value"] 1589 if !ok { 1590 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_bytes_value") 1591 } 1592 1593 protoReq.PathRepeatedBytesValue, err = runtime.BytesSlice(val, ",") 1594 if err != nil { 1595 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_bytes_value", err) 1596 } 1597 1598 val, ok = pathParams["path_repeated_uint32_value"] 1599 if !ok { 1600 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_uint32_value") 1601 } 1602 1603 protoReq.PathRepeatedUint32Value, err = runtime.Uint32Slice(val, ",") 1604 if err != nil { 1605 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_uint32_value", err) 1606 } 1607 1608 val, ok = pathParams["path_repeated_enum_value"] 1609 if !ok { 1610 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_enum_value") 1611 } 1612 1613 es, err = runtime.EnumSlice(val, ",", NumericEnum_value) 1614 if err != nil { 1615 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_enum_value", err) 1616 } 1617 1618 s := make([]NumericEnum, len(es)) 1619 for i, v := range es { 1620 s[i] = NumericEnum(v) 1621 } 1622 protoReq.PathRepeatedEnumValue = s 1623 1624 val, ok = pathParams["path_repeated_sfixed32_value"] 1625 if !ok { 1626 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed32_value") 1627 } 1628 1629 protoReq.PathRepeatedSfixed32Value, err = runtime.Int32Slice(val, ",") 1630 if err != nil { 1631 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed32_value", err) 1632 } 1633 1634 val, ok = pathParams["path_repeated_sfixed64_value"] 1635 if !ok { 1636 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sfixed64_value") 1637 } 1638 1639 protoReq.PathRepeatedSfixed64Value, err = runtime.Int64Slice(val, ",") 1640 if err != nil { 1641 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sfixed64_value", err) 1642 } 1643 1644 val, ok = pathParams["path_repeated_sint32_value"] 1645 if !ok { 1646 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint32_value") 1647 } 1648 1649 protoReq.PathRepeatedSint32Value, err = runtime.Int32Slice(val, ",") 1650 if err != nil { 1651 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint32_value", err) 1652 } 1653 1654 val, ok = pathParams["path_repeated_sint64_value"] 1655 if !ok { 1656 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "path_repeated_sint64_value") 1657 } 1658 1659 protoReq.PathRepeatedSint64Value, err = runtime.Int64Slice(val, ",") 1660 if err != nil { 1661 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "path_repeated_sint64_value", err) 1662 } 1663 1664 msg, err := server.GetRepeatedQuery(ctx, &protoReq) 1665 return msg, metadata, err 1666 1667 } 1668 1669 func request_ABitOfEverythingService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1670 var protoReq sub.StringMessage 1671 var metadata runtime.ServerMetadata 1672 1673 var ( 1674 val string 1675 ok bool 1676 err error 1677 _ = err 1678 ) 1679 1680 val, ok = pathParams["value"] 1681 if !ok { 1682 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value") 1683 } 1684 1685 protoReq.Value, err = runtime.StringP(val) 1686 if err != nil { 1687 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err) 1688 } 1689 1690 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1691 return msg, metadata, err 1692 1693 } 1694 1695 func local_request_ABitOfEverythingService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1696 var protoReq sub.StringMessage 1697 var metadata runtime.ServerMetadata 1698 1699 var ( 1700 val string 1701 ok bool 1702 err error 1703 _ = err 1704 ) 1705 1706 val, ok = pathParams["value"] 1707 if !ok { 1708 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value") 1709 } 1710 1711 protoReq.Value, err = runtime.StringP(val) 1712 if err != nil { 1713 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err) 1714 } 1715 1716 msg, err := server.Echo(ctx, &protoReq) 1717 return msg, metadata, err 1718 1719 } 1720 1721 func request_ABitOfEverythingService_Echo_1(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1722 var protoReq sub.StringMessage 1723 var metadata runtime.ServerMetadata 1724 1725 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Value); err != nil && err != io.EOF { 1726 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1727 } 1728 1729 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1730 return msg, metadata, err 1731 1732 } 1733 1734 func local_request_ABitOfEverythingService_Echo_1(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1735 var protoReq sub.StringMessage 1736 var metadata runtime.ServerMetadata 1737 1738 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Value); err != nil && err != io.EOF { 1739 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1740 } 1741 1742 msg, err := server.Echo(ctx, &protoReq) 1743 return msg, metadata, err 1744 1745 } 1746 1747 var ( 1748 filter_ABitOfEverythingService_Echo_2 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} 1749 ) 1750 1751 func request_ABitOfEverythingService_Echo_2(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1752 var protoReq sub.StringMessage 1753 var metadata runtime.ServerMetadata 1754 1755 if err := req.ParseForm(); err != nil { 1756 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1757 } 1758 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Echo_2); err != nil { 1759 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1760 } 1761 1762 msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1763 return msg, metadata, err 1764 1765 } 1766 1767 func local_request_ABitOfEverythingService_Echo_2(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1768 var protoReq sub.StringMessage 1769 var metadata runtime.ServerMetadata 1770 1771 if err := req.ParseForm(); err != nil { 1772 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1773 } 1774 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Echo_2); err != nil { 1775 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1776 } 1777 1778 msg, err := server.Echo(ctx, &protoReq) 1779 return msg, metadata, err 1780 1781 } 1782 1783 func request_ABitOfEverythingService_DeepPathEcho_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1784 var protoReq ABitOfEverything 1785 var metadata runtime.ServerMetadata 1786 1787 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 1788 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1789 } 1790 1791 var ( 1792 val string 1793 ok bool 1794 err error 1795 _ = err 1796 ) 1797 1798 val, ok = pathParams["single_nested.name"] 1799 if !ok { 1800 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name") 1801 } 1802 1803 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val) 1804 if err != nil { 1805 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err) 1806 } 1807 1808 msg, err := client.DeepPathEcho(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1809 return msg, metadata, err 1810 1811 } 1812 1813 func local_request_ABitOfEverythingService_DeepPathEcho_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1814 var protoReq ABitOfEverything 1815 var metadata runtime.ServerMetadata 1816 1817 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 1818 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1819 } 1820 1821 var ( 1822 val string 1823 ok bool 1824 err error 1825 _ = err 1826 ) 1827 1828 val, ok = pathParams["single_nested.name"] 1829 if !ok { 1830 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name") 1831 } 1832 1833 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val) 1834 if err != nil { 1835 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err) 1836 } 1837 1838 msg, err := server.DeepPathEcho(ctx, &protoReq) 1839 return msg, metadata, err 1840 1841 } 1842 1843 func request_ABitOfEverythingService_Timeout_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1844 var protoReq emptypb.Empty 1845 var metadata runtime.ServerMetadata 1846 1847 msg, err := client.Timeout(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1848 return msg, metadata, err 1849 1850 } 1851 1852 func local_request_ABitOfEverythingService_Timeout_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1853 var protoReq emptypb.Empty 1854 var metadata runtime.ServerMetadata 1855 1856 msg, err := server.Timeout(ctx, &protoReq) 1857 return msg, metadata, err 1858 1859 } 1860 1861 func request_ABitOfEverythingService_ErrorWithDetails_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1862 var protoReq emptypb.Empty 1863 var metadata runtime.ServerMetadata 1864 1865 msg, err := client.ErrorWithDetails(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1866 return msg, metadata, err 1867 1868 } 1869 1870 func local_request_ABitOfEverythingService_ErrorWithDetails_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1871 var protoReq emptypb.Empty 1872 var metadata runtime.ServerMetadata 1873 1874 msg, err := server.ErrorWithDetails(ctx, &protoReq) 1875 return msg, metadata, err 1876 1877 } 1878 1879 func request_ABitOfEverythingService_GetMessageWithBody_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1880 var protoReq MessageWithBody 1881 var metadata runtime.ServerMetadata 1882 1883 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Data); err != nil && err != io.EOF { 1884 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1885 } 1886 1887 var ( 1888 val string 1889 ok bool 1890 err error 1891 _ = err 1892 ) 1893 1894 val, ok = pathParams["id"] 1895 if !ok { 1896 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 1897 } 1898 1899 protoReq.Id, err = runtime.String(val) 1900 if err != nil { 1901 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 1902 } 1903 1904 msg, err := client.GetMessageWithBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1905 return msg, metadata, err 1906 1907 } 1908 1909 func local_request_ABitOfEverythingService_GetMessageWithBody_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1910 var protoReq MessageWithBody 1911 var metadata runtime.ServerMetadata 1912 1913 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Data); err != nil && err != io.EOF { 1914 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1915 } 1916 1917 var ( 1918 val string 1919 ok bool 1920 err error 1921 _ = err 1922 ) 1923 1924 val, ok = pathParams["id"] 1925 if !ok { 1926 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 1927 } 1928 1929 protoReq.Id, err = runtime.String(val) 1930 if err != nil { 1931 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 1932 } 1933 1934 msg, err := server.GetMessageWithBody(ctx, &protoReq) 1935 return msg, metadata, err 1936 1937 } 1938 1939 func request_ABitOfEverythingService_PostWithEmptyBody_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1940 var protoReq Body 1941 var metadata runtime.ServerMetadata 1942 1943 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 1944 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1945 } 1946 1947 var ( 1948 val string 1949 ok bool 1950 err error 1951 _ = err 1952 ) 1953 1954 val, ok = pathParams["name"] 1955 if !ok { 1956 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") 1957 } 1958 1959 protoReq.Name, err = runtime.String(val) 1960 if err != nil { 1961 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) 1962 } 1963 1964 msg, err := client.PostWithEmptyBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1965 return msg, metadata, err 1966 1967 } 1968 1969 func local_request_ABitOfEverythingService_PostWithEmptyBody_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1970 var protoReq Body 1971 var metadata runtime.ServerMetadata 1972 1973 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 1974 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 1975 } 1976 1977 var ( 1978 val string 1979 ok bool 1980 err error 1981 _ = err 1982 ) 1983 1984 val, ok = pathParams["name"] 1985 if !ok { 1986 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") 1987 } 1988 1989 protoReq.Name, err = runtime.String(val) 1990 if err != nil { 1991 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) 1992 } 1993 1994 msg, err := server.PostWithEmptyBody(ctx, &protoReq) 1995 return msg, metadata, err 1996 1997 } 1998 1999 var ( 2000 filter_ABitOfEverythingService_CheckGetQueryParams_0 = &utilities.DoubleArray{Encoding: map[string]int{"single_nested": 0, "name": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}} 2001 ) 2002 2003 func request_ABitOfEverythingService_CheckGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2004 var protoReq ABitOfEverything 2005 var metadata runtime.ServerMetadata 2006 2007 var ( 2008 val string 2009 ok bool 2010 err error 2011 _ = err 2012 ) 2013 2014 val, ok = pathParams["single_nested.name"] 2015 if !ok { 2016 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name") 2017 } 2018 2019 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val) 2020 if err != nil { 2021 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err) 2022 } 2023 2024 if err := req.ParseForm(); err != nil { 2025 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2026 } 2027 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckGetQueryParams_0); err != nil { 2028 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2029 } 2030 2031 msg, err := client.CheckGetQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2032 return msg, metadata, err 2033 2034 } 2035 2036 func local_request_ABitOfEverythingService_CheckGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2037 var protoReq ABitOfEverything 2038 var metadata runtime.ServerMetadata 2039 2040 var ( 2041 val string 2042 ok bool 2043 err error 2044 _ = err 2045 ) 2046 2047 val, ok = pathParams["single_nested.name"] 2048 if !ok { 2049 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.name") 2050 } 2051 2052 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.name", val) 2053 if err != nil { 2054 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.name", err) 2055 } 2056 2057 if err := req.ParseForm(); err != nil { 2058 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2059 } 2060 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckGetQueryParams_0); err != nil { 2061 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2062 } 2063 2064 msg, err := server.CheckGetQueryParams(ctx, &protoReq) 2065 return msg, metadata, err 2066 2067 } 2068 2069 var ( 2070 filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = &utilities.DoubleArray{Encoding: map[string]int{"single_nested": 0, "ok": 1}, Base: []int{1, 1, 1, 0}, Check: []int{0, 1, 2, 3}} 2071 ) 2072 2073 func request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2074 var protoReq ABitOfEverything 2075 var metadata runtime.ServerMetadata 2076 2077 var ( 2078 val string 2079 e int32 2080 ok bool 2081 err error 2082 _ = err 2083 ) 2084 2085 val, ok = pathParams["single_nested.ok"] 2086 if !ok { 2087 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.ok") 2088 } 2089 2090 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.ok", val) 2091 if err != nil { 2092 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.ok", err) 2093 } 2094 2095 e, err = runtime.Enum(val, ABitOfEverything_Nested_DeepEnum_value) 2096 if err != nil { 2097 return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "single_nested.ok", err) 2098 } 2099 2100 protoReq.SingleNested.Ok = ABitOfEverything_Nested_DeepEnum(e) 2101 2102 if err := req.ParseForm(); err != nil { 2103 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2104 } 2105 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0); err != nil { 2106 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2107 } 2108 2109 msg, err := client.CheckNestedEnumGetQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2110 return msg, metadata, err 2111 2112 } 2113 2114 func local_request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2115 var protoReq ABitOfEverything 2116 var metadata runtime.ServerMetadata 2117 2118 var ( 2119 val string 2120 e int32 2121 ok bool 2122 err error 2123 _ = err 2124 ) 2125 2126 val, ok = pathParams["single_nested.ok"] 2127 if !ok { 2128 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "single_nested.ok") 2129 } 2130 2131 err = runtime.PopulateFieldFromPath(&protoReq, "single_nested.ok", val) 2132 if err != nil { 2133 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "single_nested.ok", err) 2134 } 2135 2136 e, err = runtime.Enum(val, ABitOfEverything_Nested_DeepEnum_value) 2137 if err != nil { 2138 return nil, metadata, status.Errorf(codes.InvalidArgument, "could not parse path as enum value, parameter: %s, error: %v", "single_nested.ok", err) 2139 } 2140 2141 protoReq.SingleNested.Ok = ABitOfEverything_Nested_DeepEnum(e) 2142 2143 if err := req.ParseForm(); err != nil { 2144 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2145 } 2146 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0); err != nil { 2147 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2148 } 2149 2150 msg, err := server.CheckNestedEnumGetQueryParams(ctx, &protoReq) 2151 return msg, metadata, err 2152 2153 } 2154 2155 var ( 2156 filter_ABitOfEverythingService_CheckPostQueryParams_0 = &utilities.DoubleArray{Encoding: map[string]int{"single_nested": 0, "string_value": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}} 2157 ) 2158 2159 func request_ABitOfEverythingService_CheckPostQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2160 var protoReq ABitOfEverything 2161 var metadata runtime.ServerMetadata 2162 2163 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.SingleNested); err != nil && err != io.EOF { 2164 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2165 } 2166 2167 var ( 2168 val string 2169 ok bool 2170 err error 2171 _ = err 2172 ) 2173 2174 val, ok = pathParams["string_value"] 2175 if !ok { 2176 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value") 2177 } 2178 2179 protoReq.StringValue, err = runtime.String(val) 2180 if err != nil { 2181 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err) 2182 } 2183 2184 if err := req.ParseForm(); err != nil { 2185 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2186 } 2187 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckPostQueryParams_0); err != nil { 2188 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2189 } 2190 2191 msg, err := client.CheckPostQueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2192 return msg, metadata, err 2193 2194 } 2195 2196 func local_request_ABitOfEverythingService_CheckPostQueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2197 var protoReq ABitOfEverything 2198 var metadata runtime.ServerMetadata 2199 2200 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.SingleNested); err != nil && err != io.EOF { 2201 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2202 } 2203 2204 var ( 2205 val string 2206 ok bool 2207 err error 2208 _ = err 2209 ) 2210 2211 val, ok = pathParams["string_value"] 2212 if !ok { 2213 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "string_value") 2214 } 2215 2216 protoReq.StringValue, err = runtime.String(val) 2217 if err != nil { 2218 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "string_value", err) 2219 } 2220 2221 if err := req.ParseForm(); err != nil { 2222 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2223 } 2224 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CheckPostQueryParams_0); err != nil { 2225 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2226 } 2227 2228 msg, err := server.CheckPostQueryParams(ctx, &protoReq) 2229 return msg, metadata, err 2230 2231 } 2232 2233 func request_ABitOfEverythingService_OverwriteRequestContentType_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2234 var protoReq Body 2235 var metadata runtime.ServerMetadata 2236 2237 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 2238 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2239 } 2240 2241 msg, err := client.OverwriteRequestContentType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2242 return msg, metadata, err 2243 2244 } 2245 2246 func local_request_ABitOfEverythingService_OverwriteRequestContentType_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2247 var protoReq Body 2248 var metadata runtime.ServerMetadata 2249 2250 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 2251 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2252 } 2253 2254 msg, err := server.OverwriteRequestContentType(ctx, &protoReq) 2255 return msg, metadata, err 2256 2257 } 2258 2259 func request_ABitOfEverythingService_OverwriteResponseContentType_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2260 var protoReq emptypb.Empty 2261 var metadata runtime.ServerMetadata 2262 2263 msg, err := client.OverwriteResponseContentType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2264 return msg, metadata, err 2265 2266 } 2267 2268 func local_request_ABitOfEverythingService_OverwriteResponseContentType_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2269 var protoReq emptypb.Empty 2270 var metadata runtime.ServerMetadata 2271 2272 msg, err := server.OverwriteResponseContentType(ctx, &protoReq) 2273 return msg, metadata, err 2274 2275 } 2276 2277 func request_ABitOfEverythingService_CheckExternalPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2278 var protoReq pathenum.MessageWithPathEnum 2279 var metadata runtime.ServerMetadata 2280 2281 var ( 2282 val string 2283 e int32 2284 ok bool 2285 err error 2286 _ = err 2287 ) 2288 2289 val, ok = pathParams["value"] 2290 if !ok { 2291 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value") 2292 } 2293 2294 e, err = runtime.Enum(val, pathenum.PathEnum_value) 2295 if err != nil { 2296 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err) 2297 } 2298 2299 protoReq.Value = pathenum.PathEnum(e) 2300 2301 msg, err := client.CheckExternalPathEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2302 return msg, metadata, err 2303 2304 } 2305 2306 func local_request_ABitOfEverythingService_CheckExternalPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2307 var protoReq pathenum.MessageWithPathEnum 2308 var metadata runtime.ServerMetadata 2309 2310 var ( 2311 val string 2312 e int32 2313 ok bool 2314 err error 2315 _ = err 2316 ) 2317 2318 val, ok = pathParams["value"] 2319 if !ok { 2320 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value") 2321 } 2322 2323 e, err = runtime.Enum(val, pathenum.PathEnum_value) 2324 if err != nil { 2325 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err) 2326 } 2327 2328 protoReq.Value = pathenum.PathEnum(e) 2329 2330 msg, err := server.CheckExternalPathEnum(ctx, &protoReq) 2331 return msg, metadata, err 2332 2333 } 2334 2335 func request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2336 var protoReq pathenum.MessageWithNestedPathEnum 2337 var metadata runtime.ServerMetadata 2338 2339 var ( 2340 val string 2341 e int32 2342 ok bool 2343 err error 2344 _ = err 2345 ) 2346 2347 val, ok = pathParams["value"] 2348 if !ok { 2349 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value") 2350 } 2351 2352 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value) 2353 if err != nil { 2354 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err) 2355 } 2356 2357 protoReq.Value = pathenum.MessagePathEnum_NestedPathEnum(e) 2358 2359 msg, err := client.CheckExternalNestedPathEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2360 return msg, metadata, err 2361 2362 } 2363 2364 func local_request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2365 var protoReq pathenum.MessageWithNestedPathEnum 2366 var metadata runtime.ServerMetadata 2367 2368 var ( 2369 val string 2370 e int32 2371 ok bool 2372 err error 2373 _ = err 2374 ) 2375 2376 val, ok = pathParams["value"] 2377 if !ok { 2378 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "value") 2379 } 2380 2381 e, err = runtime.Enum(val, pathenum.MessagePathEnum_NestedPathEnum_value) 2382 if err != nil { 2383 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "value", err) 2384 } 2385 2386 protoReq.Value = pathenum.MessagePathEnum_NestedPathEnum(e) 2387 2388 msg, err := server.CheckExternalNestedPathEnum(ctx, &protoReq) 2389 return msg, metadata, err 2390 2391 } 2392 2393 func request_ABitOfEverythingService_CheckStatus_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2394 var protoReq emptypb.Empty 2395 var metadata runtime.ServerMetadata 2396 2397 msg, err := client.CheckStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2398 return msg, metadata, err 2399 2400 } 2401 2402 func local_request_ABitOfEverythingService_CheckStatus_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2403 var protoReq emptypb.Empty 2404 var metadata runtime.ServerMetadata 2405 2406 msg, err := server.CheckStatus(ctx, &protoReq) 2407 return msg, metadata, err 2408 2409 } 2410 2411 var ( 2412 filter_ABitOfEverythingService_Exists_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 2413 ) 2414 2415 func request_ABitOfEverythingService_Exists_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2416 var protoReq ABitOfEverything 2417 var metadata runtime.ServerMetadata 2418 2419 var ( 2420 val string 2421 ok bool 2422 err error 2423 _ = err 2424 ) 2425 2426 val, ok = pathParams["uuid"] 2427 if !ok { 2428 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 2429 } 2430 2431 protoReq.Uuid, err = runtime.String(val) 2432 if err != nil { 2433 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 2434 } 2435 2436 if err := req.ParseForm(); err != nil { 2437 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2438 } 2439 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Exists_0); err != nil { 2440 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2441 } 2442 2443 msg, err := client.Exists(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2444 return msg, metadata, err 2445 2446 } 2447 2448 func local_request_ABitOfEverythingService_Exists_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2449 var protoReq ABitOfEverything 2450 var metadata runtime.ServerMetadata 2451 2452 var ( 2453 val string 2454 ok bool 2455 err error 2456 _ = err 2457 ) 2458 2459 val, ok = pathParams["uuid"] 2460 if !ok { 2461 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 2462 } 2463 2464 protoReq.Uuid, err = runtime.String(val) 2465 if err != nil { 2466 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 2467 } 2468 2469 if err := req.ParseForm(); err != nil { 2470 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2471 } 2472 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_Exists_0); err != nil { 2473 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2474 } 2475 2476 msg, err := server.Exists(ctx, &protoReq) 2477 return msg, metadata, err 2478 2479 } 2480 2481 var ( 2482 filter_ABitOfEverythingService_CustomOptionsRequest_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 2483 ) 2484 2485 func request_ABitOfEverythingService_CustomOptionsRequest_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2486 var protoReq ABitOfEverything 2487 var metadata runtime.ServerMetadata 2488 2489 var ( 2490 val string 2491 ok bool 2492 err error 2493 _ = err 2494 ) 2495 2496 val, ok = pathParams["uuid"] 2497 if !ok { 2498 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 2499 } 2500 2501 protoReq.Uuid, err = runtime.String(val) 2502 if err != nil { 2503 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 2504 } 2505 2506 if err := req.ParseForm(); err != nil { 2507 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2508 } 2509 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CustomOptionsRequest_0); err != nil { 2510 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2511 } 2512 2513 msg, err := client.CustomOptionsRequest(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2514 return msg, metadata, err 2515 2516 } 2517 2518 func local_request_ABitOfEverythingService_CustomOptionsRequest_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2519 var protoReq ABitOfEverything 2520 var metadata runtime.ServerMetadata 2521 2522 var ( 2523 val string 2524 ok bool 2525 err error 2526 _ = err 2527 ) 2528 2529 val, ok = pathParams["uuid"] 2530 if !ok { 2531 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 2532 } 2533 2534 protoReq.Uuid, err = runtime.String(val) 2535 if err != nil { 2536 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 2537 } 2538 2539 if err := req.ParseForm(); err != nil { 2540 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2541 } 2542 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_CustomOptionsRequest_0); err != nil { 2543 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2544 } 2545 2546 msg, err := server.CustomOptionsRequest(ctx, &protoReq) 2547 return msg, metadata, err 2548 2549 } 2550 2551 var ( 2552 filter_ABitOfEverythingService_TraceRequest_0 = &utilities.DoubleArray{Encoding: map[string]int{"uuid": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 2553 ) 2554 2555 func request_ABitOfEverythingService_TraceRequest_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2556 var protoReq ABitOfEverything 2557 var metadata runtime.ServerMetadata 2558 2559 var ( 2560 val string 2561 ok bool 2562 err error 2563 _ = err 2564 ) 2565 2566 val, ok = pathParams["uuid"] 2567 if !ok { 2568 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 2569 } 2570 2571 protoReq.Uuid, err = runtime.String(val) 2572 if err != nil { 2573 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 2574 } 2575 2576 if err := req.ParseForm(); err != nil { 2577 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2578 } 2579 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_TraceRequest_0); err != nil { 2580 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2581 } 2582 2583 msg, err := client.TraceRequest(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2584 return msg, metadata, err 2585 2586 } 2587 2588 func local_request_ABitOfEverythingService_TraceRequest_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2589 var protoReq ABitOfEverything 2590 var metadata runtime.ServerMetadata 2591 2592 var ( 2593 val string 2594 ok bool 2595 err error 2596 _ = err 2597 ) 2598 2599 val, ok = pathParams["uuid"] 2600 if !ok { 2601 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "uuid") 2602 } 2603 2604 protoReq.Uuid, err = runtime.String(val) 2605 if err != nil { 2606 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "uuid", err) 2607 } 2608 2609 if err := req.ParseForm(); err != nil { 2610 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2611 } 2612 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_ABitOfEverythingService_TraceRequest_0); err != nil { 2613 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2614 } 2615 2616 msg, err := server.TraceRequest(ctx, &protoReq) 2617 return msg, metadata, err 2618 2619 } 2620 2621 func request_ABitOfEverythingService_PostOneofEnum_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2622 var protoReq oneofenum.OneofEnumMessage 2623 var metadata runtime.ServerMetadata 2624 2625 if protoReq.One == nil { 2626 protoReq.One = &oneofenum.OneofEnumMessage_ExampleEnum{} 2627 } else if _, ok := protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum); !ok { 2628 return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *oneofenum.OneofEnumMessage_ExampleEnum, but: %t\n", protoReq.One) 2629 } 2630 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum).ExampleEnum); err != nil && err != io.EOF { 2631 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2632 } 2633 2634 msg, err := client.PostOneofEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2635 return msg, metadata, err 2636 2637 } 2638 2639 func local_request_ABitOfEverythingService_PostOneofEnum_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2640 var protoReq oneofenum.OneofEnumMessage 2641 var metadata runtime.ServerMetadata 2642 2643 if protoReq.One == nil { 2644 protoReq.One = &oneofenum.OneofEnumMessage_ExampleEnum{} 2645 } else if _, ok := protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum); !ok { 2646 return nil, metadata, status.Errorf(codes.InvalidArgument, "expect type: *oneofenum.OneofEnumMessage_ExampleEnum, but: %t\n", protoReq.One) 2647 } 2648 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.One.(*oneofenum.OneofEnumMessage_ExampleEnum).ExampleEnum); err != nil && err != io.EOF { 2649 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2650 } 2651 2652 msg, err := server.PostOneofEnum(ctx, &protoReq) 2653 return msg, metadata, err 2654 2655 } 2656 2657 func request_ABitOfEverythingService_PostRequiredMessageType_0(ctx context.Context, marshaler runtime.Marshaler, client ABitOfEverythingServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2658 var protoReq RequiredMessageTypeRequest 2659 var metadata runtime.ServerMetadata 2660 2661 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 2662 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2663 } 2664 2665 msg, err := client.PostRequiredMessageType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2666 return msg, metadata, err 2667 2668 } 2669 2670 func local_request_ABitOfEverythingService_PostRequiredMessageType_0(ctx context.Context, marshaler runtime.Marshaler, server ABitOfEverythingServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2671 var protoReq RequiredMessageTypeRequest 2672 var metadata runtime.ServerMetadata 2673 2674 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { 2675 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 2676 } 2677 2678 msg, err := server.PostRequiredMessageType(ctx, &protoReq) 2679 return msg, metadata, err 2680 2681 } 2682 2683 func request_CamelCaseServiceName_Empty_0(ctx context.Context, marshaler runtime.Marshaler, client CamelCaseServiceNameClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2684 var protoReq emptypb.Empty 2685 var metadata runtime.ServerMetadata 2686 2687 msg, err := client.Empty(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2688 return msg, metadata, err 2689 2690 } 2691 2692 func local_request_CamelCaseServiceName_Empty_0(ctx context.Context, marshaler runtime.Marshaler, server CamelCaseServiceNameServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2693 var protoReq emptypb.Empty 2694 var metadata runtime.ServerMetadata 2695 2696 msg, err := server.Empty(ctx, &protoReq) 2697 return msg, metadata, err 2698 2699 } 2700 2701 func request_SnakeEnumService_SnakeEnum_0(ctx context.Context, marshaler runtime.Marshaler, client SnakeEnumServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2702 var protoReq SnakeEnumRequest 2703 var metadata runtime.ServerMetadata 2704 2705 var ( 2706 val string 2707 e int32 2708 ok bool 2709 err error 2710 _ = err 2711 ) 2712 2713 val, ok = pathParams["who"] 2714 if !ok { 2715 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "who") 2716 } 2717 2718 e, err = runtime.Enum(val, SnakeCase_0Enum_value) 2719 if err != nil { 2720 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "who", err) 2721 } 2722 2723 protoReq.Who = SnakeCase_0Enum(e) 2724 2725 val, ok = pathParams["what"] 2726 if !ok { 2727 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "what") 2728 } 2729 2730 e, err = runtime.Enum(val, SnakeCaseEnum_value) 2731 if err != nil { 2732 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "what", err) 2733 } 2734 2735 protoReq.What = SnakeCaseEnum(e) 2736 2737 val, ok = pathParams["where"] 2738 if !ok { 2739 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "where") 2740 } 2741 2742 e, err = runtime.Enum(val, pathenum.SnakeCaseForImport_value) 2743 if err != nil { 2744 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "where", err) 2745 } 2746 2747 protoReq.Where = pathenum.SnakeCaseForImport(e) 2748 2749 msg, err := client.SnakeEnum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 2750 return msg, metadata, err 2751 2752 } 2753 2754 func local_request_SnakeEnumService_SnakeEnum_0(ctx context.Context, marshaler runtime.Marshaler, server SnakeEnumServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 2755 var protoReq SnakeEnumRequest 2756 var metadata runtime.ServerMetadata 2757 2758 var ( 2759 val string 2760 e int32 2761 ok bool 2762 err error 2763 _ = err 2764 ) 2765 2766 val, ok = pathParams["who"] 2767 if !ok { 2768 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "who") 2769 } 2770 2771 e, err = runtime.Enum(val, SnakeCase_0Enum_value) 2772 if err != nil { 2773 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "who", err) 2774 } 2775 2776 protoReq.Who = SnakeCase_0Enum(e) 2777 2778 val, ok = pathParams["what"] 2779 if !ok { 2780 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "what") 2781 } 2782 2783 e, err = runtime.Enum(val, SnakeCaseEnum_value) 2784 if err != nil { 2785 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "what", err) 2786 } 2787 2788 protoReq.What = SnakeCaseEnum(e) 2789 2790 val, ok = pathParams["where"] 2791 if !ok { 2792 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "where") 2793 } 2794 2795 e, err = runtime.Enum(val, pathenum.SnakeCaseForImport_value) 2796 if err != nil { 2797 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "where", err) 2798 } 2799 2800 protoReq.Where = pathenum.SnakeCaseForImport(e) 2801 2802 msg, err := server.SnakeEnum(ctx, &protoReq) 2803 return msg, metadata, err 2804 2805 } 2806 2807 // RegisterABitOfEverythingServiceHandlerServer registers the http handlers for service ABitOfEverythingService to "mux". 2808 // UnaryRPC :call ABitOfEverythingServiceServer directly. 2809 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. 2810 // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterABitOfEverythingServiceHandlerFromEndpoint instead. 2811 func RegisterABitOfEverythingServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ABitOfEverythingServiceServer) error { 2812 2813 mux.Handle("POST", pattern_ABitOfEverythingService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2814 ctx, cancel := context.WithCancel(req.Context()) 2815 defer cancel() 2816 var stream runtime.ServerTransportStream 2817 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2818 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2819 var err error 2820 var annotatedContext context.Context 2821 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Create", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{float_value}/{double_value}/{int64_value}/separator/{uint64_value}/{int32_value}/{fixed64_value}/{fixed32_value}/{bool_value}/{string_value=strprefix/*}/{uint32_value}/{sfixed32_value}/{sfixed64_value}/{sint32_value}/{sint64_value}/{nonConventionalNameValue}/{enum_value}/{path_enum_value}/{nested_path_enum_value}/{enum_value_annotation}")) 2822 if err != nil { 2823 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2824 return 2825 } 2826 resp, md, err := local_request_ABitOfEverythingService_Create_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2827 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2828 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2829 if err != nil { 2830 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2831 return 2832 } 2833 2834 forward_ABitOfEverythingService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2835 2836 }) 2837 2838 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2839 ctx, cancel := context.WithCancel(req.Context()) 2840 defer cancel() 2841 var stream runtime.ServerTransportStream 2842 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2843 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2844 var err error 2845 var annotatedContext context.Context 2846 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBody", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything")) 2847 if err != nil { 2848 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2849 return 2850 } 2851 resp, md, err := local_request_ABitOfEverythingService_CreateBody_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2852 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2853 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2854 if err != nil { 2855 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2856 return 2857 } 2858 2859 forward_ABitOfEverythingService_CreateBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2860 2861 }) 2862 2863 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2864 ctx, cancel := context.WithCancel(req.Context()) 2865 defer cancel() 2866 var stream runtime.ServerTransportStream 2867 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2868 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2869 var err error 2870 var annotatedContext context.Context 2871 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBook", runtime.WithHTTPPathPattern("/v1/{parent=publishers/*}/books")) 2872 if err != nil { 2873 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2874 return 2875 } 2876 resp, md, err := local_request_ABitOfEverythingService_CreateBook_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2877 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2878 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2879 if err != nil { 2880 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2881 return 2882 } 2883 2884 forward_ABitOfEverythingService_CreateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2885 2886 }) 2887 2888 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2889 ctx, cancel := context.WithCancel(req.Context()) 2890 defer cancel() 2891 var stream runtime.ServerTransportStream 2892 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2893 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2894 var err error 2895 var annotatedContext context.Context 2896 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateBook", runtime.WithHTTPPathPattern("/v1/{book.name=publishers/*/books/*}")) 2897 if err != nil { 2898 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2899 return 2900 } 2901 resp, md, err := local_request_ABitOfEverythingService_UpdateBook_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2902 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2903 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2904 if err != nil { 2905 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2906 return 2907 } 2908 2909 forward_ABitOfEverythingService_UpdateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2910 2911 }) 2912 2913 mux.Handle("GET", pattern_ABitOfEverythingService_Lookup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2914 ctx, cancel := context.WithCancel(req.Context()) 2915 defer cancel() 2916 var stream runtime.ServerTransportStream 2917 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2918 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2919 var err error 2920 var annotatedContext context.Context 2921 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Lookup", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 2922 if err != nil { 2923 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2924 return 2925 } 2926 resp, md, err := local_request_ABitOfEverythingService_Lookup_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2927 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2928 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2929 if err != nil { 2930 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2931 return 2932 } 2933 2934 forward_ABitOfEverythingService_Lookup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2935 2936 }) 2937 2938 mux.Handle("POST", pattern_ABitOfEverythingService_Custom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2939 ctx, cancel := context.WithCancel(req.Context()) 2940 defer cancel() 2941 var stream runtime.ServerTransportStream 2942 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2943 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2944 var err error 2945 var annotatedContext context.Context 2946 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Custom", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom")) 2947 if err != nil { 2948 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2949 return 2950 } 2951 resp, md, err := local_request_ABitOfEverythingService_Custom_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2952 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2953 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2954 if err != nil { 2955 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2956 return 2957 } 2958 2959 forward_ABitOfEverythingService_Custom_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2960 2961 }) 2962 2963 mux.Handle("POST", pattern_ABitOfEverythingService_DoubleColon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2964 ctx, cancel := context.WithCancel(req.Context()) 2965 defer cancel() 2966 var stream runtime.ServerTransportStream 2967 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2968 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2969 var err error 2970 var annotatedContext context.Context 2971 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DoubleColon", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom:custom")) 2972 if err != nil { 2973 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2974 return 2975 } 2976 resp, md, err := local_request_ABitOfEverythingService_DoubleColon_0(annotatedContext, inboundMarshaler, server, req, pathParams) 2977 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 2978 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 2979 if err != nil { 2980 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 2981 return 2982 } 2983 2984 forward_ABitOfEverythingService_DoubleColon_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 2985 2986 }) 2987 2988 mux.Handle("PUT", pattern_ABitOfEverythingService_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 2989 ctx, cancel := context.WithCancel(req.Context()) 2990 defer cancel() 2991 var stream runtime.ServerTransportStream 2992 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 2993 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 2994 var err error 2995 var annotatedContext context.Context 2996 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Update", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 2997 if err != nil { 2998 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 2999 return 3000 } 3001 resp, md, err := local_request_ABitOfEverythingService_Update_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3002 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3003 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3004 if err != nil { 3005 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3006 return 3007 } 3008 3009 forward_ABitOfEverythingService_Update_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3010 3011 }) 3012 3013 mux.Handle("PUT", pattern_ABitOfEverythingService_UpdateV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3014 ctx, cancel := context.WithCancel(req.Context()) 3015 defer cancel() 3016 var stream runtime.ServerTransportStream 3017 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3018 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3019 var err error 3020 var annotatedContext context.Context 3021 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}")) 3022 if err != nil { 3023 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3024 return 3025 } 3026 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3027 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3028 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3029 if err != nil { 3030 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3031 return 3032 } 3033 3034 forward_ABitOfEverythingService_UpdateV2_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3035 3036 }) 3037 3038 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3039 ctx, cancel := context.WithCancel(req.Context()) 3040 defer cancel() 3041 var stream runtime.ServerTransportStream 3042 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3043 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3044 var err error 3045 var annotatedContext context.Context 3046 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}")) 3047 if err != nil { 3048 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3049 return 3050 } 3051 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_1(annotatedContext, inboundMarshaler, server, req, pathParams) 3052 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3053 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3054 if err != nil { 3055 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3056 return 3057 } 3058 3059 forward_ABitOfEverythingService_UpdateV2_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3060 3061 }) 3062 3063 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3064 ctx, cancel := context.WithCancel(req.Context()) 3065 defer cancel() 3066 var stream runtime.ServerTransportStream 3067 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3068 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3069 var err error 3070 var annotatedContext context.Context 3071 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2a/example/a_bit_of_everything/{abe.uuid}")) 3072 if err != nil { 3073 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3074 return 3075 } 3076 resp, md, err := local_request_ABitOfEverythingService_UpdateV2_2(annotatedContext, inboundMarshaler, server, req, pathParams) 3077 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3078 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3079 if err != nil { 3080 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3081 return 3082 } 3083 3084 forward_ABitOfEverythingService_UpdateV2_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3085 3086 }) 3087 3088 mux.Handle("DELETE", pattern_ABitOfEverythingService_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3089 ctx, cancel := context.WithCancel(req.Context()) 3090 defer cancel() 3091 var stream runtime.ServerTransportStream 3092 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3093 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3094 var err error 3095 var annotatedContext context.Context 3096 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Delete", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 3097 if err != nil { 3098 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3099 return 3100 } 3101 resp, md, err := local_request_ABitOfEverythingService_Delete_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3102 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3103 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3104 if err != nil { 3105 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3106 return 3107 } 3108 3109 forward_ABitOfEverythingService_Delete_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3110 3111 }) 3112 3113 mux.Handle("GET", pattern_ABitOfEverythingService_GetQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3114 ctx, cancel := context.WithCancel(req.Context()) 3115 defer cancel() 3116 var stream runtime.ServerTransportStream 3117 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3118 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3119 var err error 3120 var annotatedContext context.Context 3121 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/query/{uuid}")) 3122 if err != nil { 3123 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3124 return 3125 } 3126 resp, md, err := local_request_ABitOfEverythingService_GetQuery_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3127 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3128 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3129 if err != nil { 3130 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3131 return 3132 } 3133 3134 forward_ABitOfEverythingService_GetQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3135 3136 }) 3137 3138 mux.Handle("GET", pattern_ABitOfEverythingService_GetRepeatedQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3139 ctx, cancel := context.WithCancel(req.Context()) 3140 defer cancel() 3141 var stream runtime.ServerTransportStream 3142 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3143 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3144 var err error 3145 var annotatedContext context.Context 3146 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetRepeatedQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything_repeated/{path_repeated_float_value}/{path_repeated_double_value}/{path_repeated_int64_value}/{path_repeated_uint64_value}/{path_repeated_int32_value}/{path_repeated_fixed64_value}/{path_repeated_fixed32_value}/{path_repeated_bool_value}/{path_repeated_string_value}/{path_repeated_bytes_value}/{path_repeated_uint32_value}/{path_repeated_enum_value}/{path_repeated_sfixed32_value}/{path_repeated_sfixed64_value}/{path_repeated_sint32_value}/{path_repeated_sint64_value}")) 3147 if err != nil { 3148 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3149 return 3150 } 3151 resp, md, err := local_request_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3152 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3153 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3154 if err != nil { 3155 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3156 return 3157 } 3158 3159 forward_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3160 3161 }) 3162 3163 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3164 ctx, cancel := context.WithCancel(req.Context()) 3165 defer cancel() 3166 var stream runtime.ServerTransportStream 3167 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3168 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3169 var err error 3170 var annotatedContext context.Context 3171 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/echo/{value}")) 3172 if err != nil { 3173 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3174 return 3175 } 3176 resp, md, err := local_request_ABitOfEverythingService_Echo_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3177 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3178 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3179 if err != nil { 3180 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3181 return 3182 } 3183 3184 forward_ABitOfEverythingService_Echo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3185 3186 }) 3187 3188 mux.Handle("POST", pattern_ABitOfEverythingService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3189 ctx, cancel := context.WithCancel(req.Context()) 3190 defer cancel() 3191 var stream runtime.ServerTransportStream 3192 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3193 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3194 var err error 3195 var annotatedContext context.Context 3196 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo")) 3197 if err != nil { 3198 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3199 return 3200 } 3201 resp, md, err := local_request_ABitOfEverythingService_Echo_1(annotatedContext, inboundMarshaler, server, req, pathParams) 3202 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3203 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3204 if err != nil { 3205 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3206 return 3207 } 3208 3209 forward_ABitOfEverythingService_Echo_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3210 3211 }) 3212 3213 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3214 ctx, cancel := context.WithCancel(req.Context()) 3215 defer cancel() 3216 var stream runtime.ServerTransportStream 3217 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3218 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3219 var err error 3220 var annotatedContext context.Context 3221 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo")) 3222 if err != nil { 3223 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3224 return 3225 } 3226 resp, md, err := local_request_ABitOfEverythingService_Echo_2(annotatedContext, inboundMarshaler, server, req, pathParams) 3227 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3228 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3229 if err != nil { 3230 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3231 return 3232 } 3233 3234 forward_ABitOfEverythingService_Echo_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3235 3236 }) 3237 3238 mux.Handle("POST", pattern_ABitOfEverythingService_DeepPathEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3239 ctx, cancel := context.WithCancel(req.Context()) 3240 defer cancel() 3241 var stream runtime.ServerTransportStream 3242 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3243 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3244 var err error 3245 var annotatedContext context.Context 3246 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DeepPathEcho", runtime.WithHTTPPathPattern("/v1/example/deep_path/{single_nested.name}")) 3247 if err != nil { 3248 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3249 return 3250 } 3251 resp, md, err := local_request_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3252 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3253 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3254 if err != nil { 3255 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3256 return 3257 } 3258 3259 forward_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3260 3261 }) 3262 3263 mux.Handle("GET", pattern_ABitOfEverythingService_Timeout_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3264 ctx, cancel := context.WithCancel(req.Context()) 3265 defer cancel() 3266 var stream runtime.ServerTransportStream 3267 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3268 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3269 var err error 3270 var annotatedContext context.Context 3271 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Timeout", runtime.WithHTTPPathPattern("/v2/example/timeout")) 3272 if err != nil { 3273 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3274 return 3275 } 3276 resp, md, err := local_request_ABitOfEverythingService_Timeout_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3277 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3278 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3279 if err != nil { 3280 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3281 return 3282 } 3283 3284 forward_ABitOfEverythingService_Timeout_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3285 3286 }) 3287 3288 mux.Handle("GET", pattern_ABitOfEverythingService_ErrorWithDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3289 ctx, cancel := context.WithCancel(req.Context()) 3290 defer cancel() 3291 var stream runtime.ServerTransportStream 3292 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3293 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3294 var err error 3295 var annotatedContext context.Context 3296 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/ErrorWithDetails", runtime.WithHTTPPathPattern("/v2/example/errorwithdetails")) 3297 if err != nil { 3298 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3299 return 3300 } 3301 resp, md, err := local_request_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3302 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3303 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3304 if err != nil { 3305 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3306 return 3307 } 3308 3309 forward_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3310 3311 }) 3312 3313 mux.Handle("POST", pattern_ABitOfEverythingService_GetMessageWithBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3314 ctx, cancel := context.WithCancel(req.Context()) 3315 defer cancel() 3316 var stream runtime.ServerTransportStream 3317 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3318 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3319 var err error 3320 var annotatedContext context.Context 3321 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetMessageWithBody", runtime.WithHTTPPathPattern("/v2/example/withbody/{id}")) 3322 if err != nil { 3323 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3324 return 3325 } 3326 resp, md, err := local_request_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3327 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3328 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3329 if err != nil { 3330 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3331 return 3332 } 3333 3334 forward_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3335 3336 }) 3337 3338 mux.Handle("POST", pattern_ABitOfEverythingService_PostWithEmptyBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3339 ctx, cancel := context.WithCancel(req.Context()) 3340 defer cancel() 3341 var stream runtime.ServerTransportStream 3342 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3343 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3344 var err error 3345 var annotatedContext context.Context 3346 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostWithEmptyBody", runtime.WithHTTPPathPattern("/v2/example/postwithemptybody/{name}")) 3347 if err != nil { 3348 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3349 return 3350 } 3351 resp, md, err := local_request_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3352 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3353 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3354 if err != nil { 3355 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3356 return 3357 } 3358 3359 forward_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3360 3361 }) 3362 3363 mux.Handle("GET", pattern_ABitOfEverythingService_CheckGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3364 ctx, cancel := context.WithCancel(req.Context()) 3365 defer cancel() 3366 var stream runtime.ServerTransportStream 3367 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3368 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3369 var err error 3370 var annotatedContext context.Context 3371 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/{single_nested.name}")) 3372 if err != nil { 3373 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3374 return 3375 } 3376 resp, md, err := local_request_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3377 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3378 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3379 if err != nil { 3380 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3381 return 3382 } 3383 3384 forward_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3385 3386 }) 3387 3388 mux.Handle("GET", pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3389 ctx, cancel := context.WithCancel(req.Context()) 3390 defer cancel() 3391 var stream runtime.ServerTransportStream 3392 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3393 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3394 var err error 3395 var annotatedContext context.Context 3396 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckNestedEnumGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/nested_enum/{single_nested.ok}")) 3397 if err != nil { 3398 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3399 return 3400 } 3401 resp, md, err := local_request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3402 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3403 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3404 if err != nil { 3405 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3406 return 3407 } 3408 3409 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3410 3411 }) 3412 3413 mux.Handle("POST", pattern_ABitOfEverythingService_CheckPostQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3414 ctx, cancel := context.WithCancel(req.Context()) 3415 defer cancel() 3416 var stream runtime.ServerTransportStream 3417 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3418 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3419 var err error 3420 var annotatedContext context.Context 3421 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckPostQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/post/{string_value}")) 3422 if err != nil { 3423 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3424 return 3425 } 3426 resp, md, err := local_request_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3427 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3428 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3429 if err != nil { 3430 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3431 return 3432 } 3433 3434 forward_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3435 3436 }) 3437 3438 mux.Handle("POST", pattern_ABitOfEverythingService_OverwriteRequestContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3439 ctx, cancel := context.WithCancel(req.Context()) 3440 defer cancel() 3441 var stream runtime.ServerTransportStream 3442 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3443 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3444 var err error 3445 var annotatedContext context.Context 3446 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteRequestContentType", runtime.WithHTTPPathPattern("/v2/example/overwriterequestcontenttype")) 3447 if err != nil { 3448 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3449 return 3450 } 3451 resp, md, err := local_request_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3452 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3453 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3454 if err != nil { 3455 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3456 return 3457 } 3458 3459 forward_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3460 3461 }) 3462 3463 mux.Handle("GET", pattern_ABitOfEverythingService_OverwriteResponseContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3464 ctx, cancel := context.WithCancel(req.Context()) 3465 defer cancel() 3466 var stream runtime.ServerTransportStream 3467 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3468 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3469 var err error 3470 var annotatedContext context.Context 3471 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteResponseContentType", runtime.WithHTTPPathPattern("/v2/example/overwriteresponsecontenttype")) 3472 if err != nil { 3473 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3474 return 3475 } 3476 resp, md, err := local_request_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3477 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3478 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3479 if err != nil { 3480 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3481 return 3482 } 3483 3484 forward_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3485 3486 }) 3487 3488 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3489 ctx, cancel := context.WithCancel(req.Context()) 3490 defer cancel() 3491 var stream runtime.ServerTransportStream 3492 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3493 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3494 var err error 3495 var annotatedContext context.Context 3496 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalPathEnum", runtime.WithHTTPPathPattern("/v2/{value}:check")) 3497 if err != nil { 3498 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3499 return 3500 } 3501 resp, md, err := local_request_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3502 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3503 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3504 if err != nil { 3505 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3506 return 3507 } 3508 3509 forward_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3510 3511 }) 3512 3513 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3514 ctx, cancel := context.WithCancel(req.Context()) 3515 defer cancel() 3516 var stream runtime.ServerTransportStream 3517 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3518 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3519 var err error 3520 var annotatedContext context.Context 3521 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalNestedPathEnum", runtime.WithHTTPPathPattern("/v3/{value}:check")) 3522 if err != nil { 3523 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3524 return 3525 } 3526 resp, md, err := local_request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3527 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3528 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3529 if err != nil { 3530 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3531 return 3532 } 3533 3534 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3535 3536 }) 3537 3538 mux.Handle("GET", pattern_ABitOfEverythingService_CheckStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3539 ctx, cancel := context.WithCancel(req.Context()) 3540 defer cancel() 3541 var stream runtime.ServerTransportStream 3542 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3543 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3544 var err error 3545 var annotatedContext context.Context 3546 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckStatus", runtime.WithHTTPPathPattern("/v1/example/checkStatus")) 3547 if err != nil { 3548 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3549 return 3550 } 3551 resp, md, err := local_request_ABitOfEverythingService_CheckStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3552 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3553 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3554 if err != nil { 3555 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3556 return 3557 } 3558 3559 forward_ABitOfEverythingService_CheckStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3560 3561 }) 3562 3563 mux.Handle("HEAD", pattern_ABitOfEverythingService_Exists_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3564 ctx, cancel := context.WithCancel(req.Context()) 3565 defer cancel() 3566 var stream runtime.ServerTransportStream 3567 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3568 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3569 var err error 3570 var annotatedContext context.Context 3571 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Exists", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 3572 if err != nil { 3573 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3574 return 3575 } 3576 resp, md, err := local_request_ABitOfEverythingService_Exists_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3577 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3578 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3579 if err != nil { 3580 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3581 return 3582 } 3583 3584 forward_ABitOfEverythingService_Exists_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3585 3586 }) 3587 3588 mux.Handle("OPTIONS", pattern_ABitOfEverythingService_CustomOptionsRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3589 ctx, cancel := context.WithCancel(req.Context()) 3590 defer cancel() 3591 var stream runtime.ServerTransportStream 3592 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3593 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3594 var err error 3595 var annotatedContext context.Context 3596 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CustomOptionsRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 3597 if err != nil { 3598 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3599 return 3600 } 3601 resp, md, err := local_request_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3602 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3603 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3604 if err != nil { 3605 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3606 return 3607 } 3608 3609 forward_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3610 3611 }) 3612 3613 mux.Handle("TRACE", pattern_ABitOfEverythingService_TraceRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3614 ctx, cancel := context.WithCancel(req.Context()) 3615 defer cancel() 3616 var stream runtime.ServerTransportStream 3617 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3618 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3619 var err error 3620 var annotatedContext context.Context 3621 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/TraceRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 3622 if err != nil { 3623 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3624 return 3625 } 3626 resp, md, err := local_request_ABitOfEverythingService_TraceRequest_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3627 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3628 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3629 if err != nil { 3630 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3631 return 3632 } 3633 3634 forward_ABitOfEverythingService_TraceRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3635 3636 }) 3637 3638 mux.Handle("POST", pattern_ABitOfEverythingService_PostOneofEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3639 ctx, cancel := context.WithCancel(req.Context()) 3640 defer cancel() 3641 var stream runtime.ServerTransportStream 3642 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3643 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3644 var err error 3645 var annotatedContext context.Context 3646 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostOneofEnum", runtime.WithHTTPPathPattern("/v1/example/oneofenum")) 3647 if err != nil { 3648 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3649 return 3650 } 3651 resp, md, err := local_request_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3652 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3653 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3654 if err != nil { 3655 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3656 return 3657 } 3658 3659 forward_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3660 3661 }) 3662 3663 mux.Handle("POST", pattern_ABitOfEverythingService_PostRequiredMessageType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3664 ctx, cancel := context.WithCancel(req.Context()) 3665 defer cancel() 3666 var stream runtime.ServerTransportStream 3667 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3668 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3669 var err error 3670 var annotatedContext context.Context 3671 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostRequiredMessageType", runtime.WithHTTPPathPattern("/v1/example/requiredmessagetype")) 3672 if err != nil { 3673 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3674 return 3675 } 3676 resp, md, err := local_request_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3677 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3678 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3679 if err != nil { 3680 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3681 return 3682 } 3683 3684 forward_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3685 3686 }) 3687 3688 return nil 3689 } 3690 3691 // RegisterCamelCaseServiceNameHandlerServer registers the http handlers for service CamelCaseServiceName to "mux". 3692 // UnaryRPC :call CamelCaseServiceNameServer directly. 3693 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. 3694 // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCamelCaseServiceNameHandlerFromEndpoint instead. 3695 func RegisterCamelCaseServiceNameHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CamelCaseServiceNameServer) error { 3696 3697 mux.Handle("GET", pattern_CamelCaseServiceName_Empty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3698 ctx, cancel := context.WithCancel(req.Context()) 3699 defer cancel() 3700 var stream runtime.ServerTransportStream 3701 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3702 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3703 var err error 3704 var annotatedContext context.Context 3705 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.CamelCaseServiceName/Empty", runtime.WithHTTPPathPattern("/v2/example/empty")) 3706 if err != nil { 3707 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3708 return 3709 } 3710 resp, md, err := local_request_CamelCaseServiceName_Empty_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3711 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3712 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3713 if err != nil { 3714 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3715 return 3716 } 3717 3718 forward_CamelCaseServiceName_Empty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3719 3720 }) 3721 3722 return nil 3723 } 3724 3725 // RegisterSnakeEnumServiceHandlerServer registers the http handlers for service SnakeEnumService to "mux". 3726 // UnaryRPC :call SnakeEnumServiceServer directly. 3727 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. 3728 // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSnakeEnumServiceHandlerFromEndpoint instead. 3729 func RegisterSnakeEnumServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SnakeEnumServiceServer) error { 3730 3731 mux.Handle("GET", pattern_SnakeEnumService_SnakeEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3732 ctx, cancel := context.WithCancel(req.Context()) 3733 defer cancel() 3734 var stream runtime.ServerTransportStream 3735 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 3736 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3737 var err error 3738 var annotatedContext context.Context 3739 annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.SnakeEnumService/SnakeEnum", runtime.WithHTTPPathPattern("/v1/example/snake/{who}/{what}/{where}")) 3740 if err != nil { 3741 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3742 return 3743 } 3744 resp, md, err := local_request_SnakeEnumService_SnakeEnum_0(annotatedContext, inboundMarshaler, server, req, pathParams) 3745 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 3746 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3747 if err != nil { 3748 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3749 return 3750 } 3751 3752 forward_SnakeEnumService_SnakeEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3753 3754 }) 3755 3756 return nil 3757 } 3758 3759 // RegisterABitOfEverythingServiceHandlerFromEndpoint is same as RegisterABitOfEverythingServiceHandler but 3760 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 3761 func RegisterABitOfEverythingServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 3762 conn, err := grpc.DialContext(ctx, endpoint, opts...) 3763 if err != nil { 3764 return err 3765 } 3766 defer func() { 3767 if err != nil { 3768 if cerr := conn.Close(); cerr != nil { 3769 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 3770 } 3771 return 3772 } 3773 go func() { 3774 <-ctx.Done() 3775 if cerr := conn.Close(); cerr != nil { 3776 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 3777 } 3778 }() 3779 }() 3780 3781 return RegisterABitOfEverythingServiceHandler(ctx, mux, conn) 3782 } 3783 3784 // RegisterABitOfEverythingServiceHandler registers the http handlers for service ABitOfEverythingService to "mux". 3785 // The handlers forward requests to the grpc endpoint over "conn". 3786 func RegisterABitOfEverythingServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 3787 return RegisterABitOfEverythingServiceHandlerClient(ctx, mux, NewABitOfEverythingServiceClient(conn)) 3788 } 3789 3790 // RegisterABitOfEverythingServiceHandlerClient registers the http handlers for service ABitOfEverythingService 3791 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ABitOfEverythingServiceClient". 3792 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ABitOfEverythingServiceClient" 3793 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 3794 // "ABitOfEverythingServiceClient" to call the correct interceptors. 3795 func RegisterABitOfEverythingServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ABitOfEverythingServiceClient) error { 3796 3797 mux.Handle("POST", pattern_ABitOfEverythingService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3798 ctx, cancel := context.WithCancel(req.Context()) 3799 defer cancel() 3800 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3801 var err error 3802 var annotatedContext context.Context 3803 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Create", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{float_value}/{double_value}/{int64_value}/separator/{uint64_value}/{int32_value}/{fixed64_value}/{fixed32_value}/{bool_value}/{string_value=strprefix/*}/{uint32_value}/{sfixed32_value}/{sfixed64_value}/{sint32_value}/{sint64_value}/{nonConventionalNameValue}/{enum_value}/{path_enum_value}/{nested_path_enum_value}/{enum_value_annotation}")) 3804 if err != nil { 3805 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3806 return 3807 } 3808 resp, md, err := request_ABitOfEverythingService_Create_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3809 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3810 if err != nil { 3811 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3812 return 3813 } 3814 3815 forward_ABitOfEverythingService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3816 3817 }) 3818 3819 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3820 ctx, cancel := context.WithCancel(req.Context()) 3821 defer cancel() 3822 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3823 var err error 3824 var annotatedContext context.Context 3825 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBody", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything")) 3826 if err != nil { 3827 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3828 return 3829 } 3830 resp, md, err := request_ABitOfEverythingService_CreateBody_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3831 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3832 if err != nil { 3833 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3834 return 3835 } 3836 3837 forward_ABitOfEverythingService_CreateBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3838 3839 }) 3840 3841 mux.Handle("POST", pattern_ABitOfEverythingService_CreateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3842 ctx, cancel := context.WithCancel(req.Context()) 3843 defer cancel() 3844 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3845 var err error 3846 var annotatedContext context.Context 3847 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBook", runtime.WithHTTPPathPattern("/v1/{parent=publishers/*}/books")) 3848 if err != nil { 3849 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3850 return 3851 } 3852 resp, md, err := request_ABitOfEverythingService_CreateBook_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3853 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3854 if err != nil { 3855 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3856 return 3857 } 3858 3859 forward_ABitOfEverythingService_CreateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3860 3861 }) 3862 3863 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateBook_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3864 ctx, cancel := context.WithCancel(req.Context()) 3865 defer cancel() 3866 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3867 var err error 3868 var annotatedContext context.Context 3869 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateBook", runtime.WithHTTPPathPattern("/v1/{book.name=publishers/*/books/*}")) 3870 if err != nil { 3871 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3872 return 3873 } 3874 resp, md, err := request_ABitOfEverythingService_UpdateBook_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3875 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3876 if err != nil { 3877 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3878 return 3879 } 3880 3881 forward_ABitOfEverythingService_UpdateBook_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3882 3883 }) 3884 3885 mux.Handle("GET", pattern_ABitOfEverythingService_Lookup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3886 ctx, cancel := context.WithCancel(req.Context()) 3887 defer cancel() 3888 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3889 var err error 3890 var annotatedContext context.Context 3891 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Lookup", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 3892 if err != nil { 3893 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3894 return 3895 } 3896 resp, md, err := request_ABitOfEverythingService_Lookup_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3897 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3898 if err != nil { 3899 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3900 return 3901 } 3902 3903 forward_ABitOfEverythingService_Lookup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3904 3905 }) 3906 3907 mux.Handle("POST", pattern_ABitOfEverythingService_Custom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3908 ctx, cancel := context.WithCancel(req.Context()) 3909 defer cancel() 3910 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3911 var err error 3912 var annotatedContext context.Context 3913 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Custom", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom")) 3914 if err != nil { 3915 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3916 return 3917 } 3918 resp, md, err := request_ABitOfEverythingService_Custom_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3919 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3920 if err != nil { 3921 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3922 return 3923 } 3924 3925 forward_ABitOfEverythingService_Custom_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3926 3927 }) 3928 3929 mux.Handle("POST", pattern_ABitOfEverythingService_DoubleColon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3930 ctx, cancel := context.WithCancel(req.Context()) 3931 defer cancel() 3932 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3933 var err error 3934 var annotatedContext context.Context 3935 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DoubleColon", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}:custom:custom")) 3936 if err != nil { 3937 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3938 return 3939 } 3940 resp, md, err := request_ABitOfEverythingService_DoubleColon_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3941 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3942 if err != nil { 3943 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3944 return 3945 } 3946 3947 forward_ABitOfEverythingService_DoubleColon_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3948 3949 }) 3950 3951 mux.Handle("PUT", pattern_ABitOfEverythingService_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3952 ctx, cancel := context.WithCancel(req.Context()) 3953 defer cancel() 3954 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3955 var err error 3956 var annotatedContext context.Context 3957 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Update", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 3958 if err != nil { 3959 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3960 return 3961 } 3962 resp, md, err := request_ABitOfEverythingService_Update_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3963 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3964 if err != nil { 3965 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3966 return 3967 } 3968 3969 forward_ABitOfEverythingService_Update_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3970 3971 }) 3972 3973 mux.Handle("PUT", pattern_ABitOfEverythingService_UpdateV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3974 ctx, cancel := context.WithCancel(req.Context()) 3975 defer cancel() 3976 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3977 var err error 3978 var annotatedContext context.Context 3979 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}")) 3980 if err != nil { 3981 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 3982 return 3983 } 3984 resp, md, err := request_ABitOfEverythingService_UpdateV2_0(annotatedContext, inboundMarshaler, client, req, pathParams) 3985 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 3986 if err != nil { 3987 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 3988 return 3989 } 3990 3991 forward_ABitOfEverythingService_UpdateV2_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 3992 3993 }) 3994 3995 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 3996 ctx, cancel := context.WithCancel(req.Context()) 3997 defer cancel() 3998 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 3999 var err error 4000 var annotatedContext context.Context 4001 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2/example/a_bit_of_everything/{abe.uuid}")) 4002 if err != nil { 4003 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4004 return 4005 } 4006 resp, md, err := request_ABitOfEverythingService_UpdateV2_1(annotatedContext, inboundMarshaler, client, req, pathParams) 4007 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4008 if err != nil { 4009 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4010 return 4011 } 4012 4013 forward_ABitOfEverythingService_UpdateV2_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4014 4015 }) 4016 4017 mux.Handle("PATCH", pattern_ABitOfEverythingService_UpdateV2_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4018 ctx, cancel := context.WithCancel(req.Context()) 4019 defer cancel() 4020 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4021 var err error 4022 var annotatedContext context.Context 4023 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2", runtime.WithHTTPPathPattern("/v2a/example/a_bit_of_everything/{abe.uuid}")) 4024 if err != nil { 4025 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4026 return 4027 } 4028 resp, md, err := request_ABitOfEverythingService_UpdateV2_2(annotatedContext, inboundMarshaler, client, req, pathParams) 4029 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4030 if err != nil { 4031 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4032 return 4033 } 4034 4035 forward_ABitOfEverythingService_UpdateV2_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4036 4037 }) 4038 4039 mux.Handle("DELETE", pattern_ABitOfEverythingService_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4040 ctx, cancel := context.WithCancel(req.Context()) 4041 defer cancel() 4042 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4043 var err error 4044 var annotatedContext context.Context 4045 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Delete", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 4046 if err != nil { 4047 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4048 return 4049 } 4050 resp, md, err := request_ABitOfEverythingService_Delete_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4051 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4052 if err != nil { 4053 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4054 return 4055 } 4056 4057 forward_ABitOfEverythingService_Delete_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4058 4059 }) 4060 4061 mux.Handle("GET", pattern_ABitOfEverythingService_GetQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4062 ctx, cancel := context.WithCancel(req.Context()) 4063 defer cancel() 4064 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4065 var err error 4066 var annotatedContext context.Context 4067 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/query/{uuid}")) 4068 if err != nil { 4069 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4070 return 4071 } 4072 resp, md, err := request_ABitOfEverythingService_GetQuery_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4073 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4074 if err != nil { 4075 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4076 return 4077 } 4078 4079 forward_ABitOfEverythingService_GetQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4080 4081 }) 4082 4083 mux.Handle("GET", pattern_ABitOfEverythingService_GetRepeatedQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4084 ctx, cancel := context.WithCancel(req.Context()) 4085 defer cancel() 4086 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4087 var err error 4088 var annotatedContext context.Context 4089 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetRepeatedQuery", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything_repeated/{path_repeated_float_value}/{path_repeated_double_value}/{path_repeated_int64_value}/{path_repeated_uint64_value}/{path_repeated_int32_value}/{path_repeated_fixed64_value}/{path_repeated_fixed32_value}/{path_repeated_bool_value}/{path_repeated_string_value}/{path_repeated_bytes_value}/{path_repeated_uint32_value}/{path_repeated_enum_value}/{path_repeated_sfixed32_value}/{path_repeated_sfixed64_value}/{path_repeated_sint32_value}/{path_repeated_sint64_value}")) 4090 if err != nil { 4091 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4092 return 4093 } 4094 resp, md, err := request_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4095 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4096 if err != nil { 4097 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4098 return 4099 } 4100 4101 forward_ABitOfEverythingService_GetRepeatedQuery_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4102 4103 }) 4104 4105 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4106 ctx, cancel := context.WithCancel(req.Context()) 4107 defer cancel() 4108 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4109 var err error 4110 var annotatedContext context.Context 4111 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/echo/{value}")) 4112 if err != nil { 4113 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4114 return 4115 } 4116 resp, md, err := request_ABitOfEverythingService_Echo_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4117 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4118 if err != nil { 4119 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4120 return 4121 } 4122 4123 forward_ABitOfEverythingService_Echo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4124 4125 }) 4126 4127 mux.Handle("POST", pattern_ABitOfEverythingService_Echo_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4128 ctx, cancel := context.WithCancel(req.Context()) 4129 defer cancel() 4130 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4131 var err error 4132 var annotatedContext context.Context 4133 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo")) 4134 if err != nil { 4135 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4136 return 4137 } 4138 resp, md, err := request_ABitOfEverythingService_Echo_1(annotatedContext, inboundMarshaler, client, req, pathParams) 4139 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4140 if err != nil { 4141 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4142 return 4143 } 4144 4145 forward_ABitOfEverythingService_Echo_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4146 4147 }) 4148 4149 mux.Handle("GET", pattern_ABitOfEverythingService_Echo_2, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4150 ctx, cancel := context.WithCancel(req.Context()) 4151 defer cancel() 4152 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4153 var err error 4154 var annotatedContext context.Context 4155 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo", runtime.WithHTTPPathPattern("/v2/example/echo")) 4156 if err != nil { 4157 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4158 return 4159 } 4160 resp, md, err := request_ABitOfEverythingService_Echo_2(annotatedContext, inboundMarshaler, client, req, pathParams) 4161 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4162 if err != nil { 4163 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4164 return 4165 } 4166 4167 forward_ABitOfEverythingService_Echo_2(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4168 4169 }) 4170 4171 mux.Handle("POST", pattern_ABitOfEverythingService_DeepPathEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4172 ctx, cancel := context.WithCancel(req.Context()) 4173 defer cancel() 4174 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4175 var err error 4176 var annotatedContext context.Context 4177 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DeepPathEcho", runtime.WithHTTPPathPattern("/v1/example/deep_path/{single_nested.name}")) 4178 if err != nil { 4179 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4180 return 4181 } 4182 resp, md, err := request_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4183 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4184 if err != nil { 4185 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4186 return 4187 } 4188 4189 forward_ABitOfEverythingService_DeepPathEcho_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4190 4191 }) 4192 4193 mux.Handle("GET", pattern_ABitOfEverythingService_Timeout_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4194 ctx, cancel := context.WithCancel(req.Context()) 4195 defer cancel() 4196 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4197 var err error 4198 var annotatedContext context.Context 4199 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Timeout", runtime.WithHTTPPathPattern("/v2/example/timeout")) 4200 if err != nil { 4201 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4202 return 4203 } 4204 resp, md, err := request_ABitOfEverythingService_Timeout_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4205 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4206 if err != nil { 4207 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4208 return 4209 } 4210 4211 forward_ABitOfEverythingService_Timeout_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4212 4213 }) 4214 4215 mux.Handle("GET", pattern_ABitOfEverythingService_ErrorWithDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4216 ctx, cancel := context.WithCancel(req.Context()) 4217 defer cancel() 4218 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4219 var err error 4220 var annotatedContext context.Context 4221 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/ErrorWithDetails", runtime.WithHTTPPathPattern("/v2/example/errorwithdetails")) 4222 if err != nil { 4223 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4224 return 4225 } 4226 resp, md, err := request_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4227 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4228 if err != nil { 4229 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4230 return 4231 } 4232 4233 forward_ABitOfEverythingService_ErrorWithDetails_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4234 4235 }) 4236 4237 mux.Handle("POST", pattern_ABitOfEverythingService_GetMessageWithBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4238 ctx, cancel := context.WithCancel(req.Context()) 4239 defer cancel() 4240 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4241 var err error 4242 var annotatedContext context.Context 4243 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetMessageWithBody", runtime.WithHTTPPathPattern("/v2/example/withbody/{id}")) 4244 if err != nil { 4245 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4246 return 4247 } 4248 resp, md, err := request_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4249 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4250 if err != nil { 4251 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4252 return 4253 } 4254 4255 forward_ABitOfEverythingService_GetMessageWithBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4256 4257 }) 4258 4259 mux.Handle("POST", pattern_ABitOfEverythingService_PostWithEmptyBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4260 ctx, cancel := context.WithCancel(req.Context()) 4261 defer cancel() 4262 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4263 var err error 4264 var annotatedContext context.Context 4265 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostWithEmptyBody", runtime.WithHTTPPathPattern("/v2/example/postwithemptybody/{name}")) 4266 if err != nil { 4267 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4268 return 4269 } 4270 resp, md, err := request_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4271 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4272 if err != nil { 4273 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4274 return 4275 } 4276 4277 forward_ABitOfEverythingService_PostWithEmptyBody_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4278 4279 }) 4280 4281 mux.Handle("GET", pattern_ABitOfEverythingService_CheckGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4282 ctx, cancel := context.WithCancel(req.Context()) 4283 defer cancel() 4284 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4285 var err error 4286 var annotatedContext context.Context 4287 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/{single_nested.name}")) 4288 if err != nil { 4289 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4290 return 4291 } 4292 resp, md, err := request_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4293 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4294 if err != nil { 4295 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4296 return 4297 } 4298 4299 forward_ABitOfEverythingService_CheckGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4300 4301 }) 4302 4303 mux.Handle("GET", pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4304 ctx, cancel := context.WithCancel(req.Context()) 4305 defer cancel() 4306 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4307 var err error 4308 var annotatedContext context.Context 4309 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckNestedEnumGetQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/get/nested_enum/{single_nested.ok}")) 4310 if err != nil { 4311 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4312 return 4313 } 4314 resp, md, err := request_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4315 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4316 if err != nil { 4317 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4318 return 4319 } 4320 4321 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4322 4323 }) 4324 4325 mux.Handle("POST", pattern_ABitOfEverythingService_CheckPostQueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4326 ctx, cancel := context.WithCancel(req.Context()) 4327 defer cancel() 4328 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4329 var err error 4330 var annotatedContext context.Context 4331 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckPostQueryParams", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/params/post/{string_value}")) 4332 if err != nil { 4333 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4334 return 4335 } 4336 resp, md, err := request_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4337 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4338 if err != nil { 4339 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4340 return 4341 } 4342 4343 forward_ABitOfEverythingService_CheckPostQueryParams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4344 4345 }) 4346 4347 mux.Handle("POST", pattern_ABitOfEverythingService_OverwriteRequestContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4348 ctx, cancel := context.WithCancel(req.Context()) 4349 defer cancel() 4350 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4351 var err error 4352 var annotatedContext context.Context 4353 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteRequestContentType", runtime.WithHTTPPathPattern("/v2/example/overwriterequestcontenttype")) 4354 if err != nil { 4355 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4356 return 4357 } 4358 resp, md, err := request_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4359 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4360 if err != nil { 4361 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4362 return 4363 } 4364 4365 forward_ABitOfEverythingService_OverwriteRequestContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4366 4367 }) 4368 4369 mux.Handle("GET", pattern_ABitOfEverythingService_OverwriteResponseContentType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4370 ctx, cancel := context.WithCancel(req.Context()) 4371 defer cancel() 4372 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4373 var err error 4374 var annotatedContext context.Context 4375 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteResponseContentType", runtime.WithHTTPPathPattern("/v2/example/overwriteresponsecontenttype")) 4376 if err != nil { 4377 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4378 return 4379 } 4380 resp, md, err := request_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4381 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4382 if err != nil { 4383 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4384 return 4385 } 4386 4387 forward_ABitOfEverythingService_OverwriteResponseContentType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4388 4389 }) 4390 4391 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4392 ctx, cancel := context.WithCancel(req.Context()) 4393 defer cancel() 4394 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4395 var err error 4396 var annotatedContext context.Context 4397 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalPathEnum", runtime.WithHTTPPathPattern("/v2/{value}:check")) 4398 if err != nil { 4399 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4400 return 4401 } 4402 resp, md, err := request_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4403 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4404 if err != nil { 4405 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4406 return 4407 } 4408 4409 forward_ABitOfEverythingService_CheckExternalPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4410 4411 }) 4412 4413 mux.Handle("GET", pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4414 ctx, cancel := context.WithCancel(req.Context()) 4415 defer cancel() 4416 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4417 var err error 4418 var annotatedContext context.Context 4419 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalNestedPathEnum", runtime.WithHTTPPathPattern("/v3/{value}:check")) 4420 if err != nil { 4421 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4422 return 4423 } 4424 resp, md, err := request_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4425 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4426 if err != nil { 4427 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4428 return 4429 } 4430 4431 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4432 4433 }) 4434 4435 mux.Handle("GET", pattern_ABitOfEverythingService_CheckStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4436 ctx, cancel := context.WithCancel(req.Context()) 4437 defer cancel() 4438 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4439 var err error 4440 var annotatedContext context.Context 4441 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckStatus", runtime.WithHTTPPathPattern("/v1/example/checkStatus")) 4442 if err != nil { 4443 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4444 return 4445 } 4446 resp, md, err := request_ABitOfEverythingService_CheckStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4447 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4448 if err != nil { 4449 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4450 return 4451 } 4452 4453 forward_ABitOfEverythingService_CheckStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4454 4455 }) 4456 4457 mux.Handle("HEAD", pattern_ABitOfEverythingService_Exists_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4458 ctx, cancel := context.WithCancel(req.Context()) 4459 defer cancel() 4460 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4461 var err error 4462 var annotatedContext context.Context 4463 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Exists", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 4464 if err != nil { 4465 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4466 return 4467 } 4468 resp, md, err := request_ABitOfEverythingService_Exists_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4469 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4470 if err != nil { 4471 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4472 return 4473 } 4474 4475 forward_ABitOfEverythingService_Exists_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4476 4477 }) 4478 4479 mux.Handle("OPTIONS", pattern_ABitOfEverythingService_CustomOptionsRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4480 ctx, cancel := context.WithCancel(req.Context()) 4481 defer cancel() 4482 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4483 var err error 4484 var annotatedContext context.Context 4485 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CustomOptionsRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 4486 if err != nil { 4487 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4488 return 4489 } 4490 resp, md, err := request_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4491 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4492 if err != nil { 4493 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4494 return 4495 } 4496 4497 forward_ABitOfEverythingService_CustomOptionsRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4498 4499 }) 4500 4501 mux.Handle("TRACE", pattern_ABitOfEverythingService_TraceRequest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4502 ctx, cancel := context.WithCancel(req.Context()) 4503 defer cancel() 4504 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4505 var err error 4506 var annotatedContext context.Context 4507 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/TraceRequest", runtime.WithHTTPPathPattern("/v1/example/a_bit_of_everything/{uuid}")) 4508 if err != nil { 4509 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4510 return 4511 } 4512 resp, md, err := request_ABitOfEverythingService_TraceRequest_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4513 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4514 if err != nil { 4515 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4516 return 4517 } 4518 4519 forward_ABitOfEverythingService_TraceRequest_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4520 4521 }) 4522 4523 mux.Handle("POST", pattern_ABitOfEverythingService_PostOneofEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4524 ctx, cancel := context.WithCancel(req.Context()) 4525 defer cancel() 4526 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4527 var err error 4528 var annotatedContext context.Context 4529 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostOneofEnum", runtime.WithHTTPPathPattern("/v1/example/oneofenum")) 4530 if err != nil { 4531 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4532 return 4533 } 4534 resp, md, err := request_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4535 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4536 if err != nil { 4537 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4538 return 4539 } 4540 4541 forward_ABitOfEverythingService_PostOneofEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4542 4543 }) 4544 4545 mux.Handle("POST", pattern_ABitOfEverythingService_PostRequiredMessageType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4546 ctx, cancel := context.WithCancel(req.Context()) 4547 defer cancel() 4548 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4549 var err error 4550 var annotatedContext context.Context 4551 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostRequiredMessageType", runtime.WithHTTPPathPattern("/v1/example/requiredmessagetype")) 4552 if err != nil { 4553 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4554 return 4555 } 4556 resp, md, err := request_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4557 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4558 if err != nil { 4559 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4560 return 4561 } 4562 4563 forward_ABitOfEverythingService_PostRequiredMessageType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4564 4565 }) 4566 4567 return nil 4568 } 4569 4570 var ( 4571 pattern_ABitOfEverythingService_Create_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 2, 6, 1, 0, 4, 1, 5, 7, 1, 0, 4, 1, 5, 8, 1, 0, 4, 1, 5, 9, 1, 0, 4, 1, 5, 10, 1, 0, 4, 1, 5, 11, 2, 12, 1, 0, 4, 2, 5, 13, 1, 0, 4, 1, 5, 14, 1, 0, 4, 1, 5, 15, 1, 0, 4, 1, 5, 16, 1, 0, 4, 1, 5, 17, 1, 0, 4, 1, 5, 18, 1, 0, 4, 1, 5, 19, 1, 0, 4, 1, 5, 20, 1, 0, 4, 1, 5, 21, 1, 0, 4, 1, 5, 22, 1, 0, 4, 1, 5, 23}, []string{"v1", "example", "a_bit_of_everything", "float_value", "double_value", "int64_value", "separator", "uint64_value", "int32_value", "fixed64_value", "fixed32_value", "bool_value", "strprefix", "string_value", "uint32_value", "sfixed32_value", "sfixed64_value", "sint32_value", "sint64_value", "nonConventionalNameValue", "enum_value", "path_enum_value", "nested_path_enum_value", "enum_value_annotation"}, "")) 4572 4573 pattern_ABitOfEverythingService_CreateBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "a_bit_of_everything"}, "")) 4574 4575 pattern_ABitOfEverythingService_CreateBook_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "publishers", "parent", "books"}, "")) 4576 4577 pattern_ABitOfEverythingService_UpdateBook_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "publishers", "books", "book.name"}, "")) 4578 4579 pattern_ABitOfEverythingService_Lookup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "")) 4580 4581 pattern_ABitOfEverythingService_Custom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "custom")) 4582 4583 pattern_ABitOfEverythingService_DoubleColon_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "custom:custom")) 4584 4585 pattern_ABitOfEverythingService_Update_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "")) 4586 4587 pattern_ABitOfEverythingService_UpdateV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "a_bit_of_everything", "abe.uuid"}, "")) 4588 4589 pattern_ABitOfEverythingService_UpdateV2_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "a_bit_of_everything", "abe.uuid"}, "")) 4590 4591 pattern_ABitOfEverythingService_UpdateV2_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2a", "example", "a_bit_of_everything", "abe.uuid"}, "")) 4592 4593 pattern_ABitOfEverythingService_Delete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "")) 4594 4595 pattern_ABitOfEverythingService_GetQuery_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "a_bit_of_everything", "query", "uuid"}, "")) 4596 4597 pattern_ABitOfEverythingService_GetRepeatedQuery_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 1, 0, 4, 1, 5, 7, 1, 0, 4, 1, 5, 8, 1, 0, 4, 1, 5, 9, 1, 0, 4, 1, 5, 10, 1, 0, 4, 1, 5, 11, 1, 0, 4, 1, 5, 12, 1, 0, 4, 1, 5, 13, 1, 0, 4, 1, 5, 14, 1, 0, 4, 1, 5, 15, 1, 0, 4, 1, 5, 16, 1, 0, 4, 1, 5, 17, 1, 0, 4, 1, 5, 18}, []string{"v1", "example", "a_bit_of_everything_repeated", "path_repeated_float_value", "path_repeated_double_value", "path_repeated_int64_value", "path_repeated_uint64_value", "path_repeated_int32_value", "path_repeated_fixed64_value", "path_repeated_fixed32_value", "path_repeated_bool_value", "path_repeated_string_value", "path_repeated_bytes_value", "path_repeated_uint32_value", "path_repeated_enum_value", "path_repeated_sfixed32_value", "path_repeated_sfixed64_value", "path_repeated_sint32_value", "path_repeated_sint64_value"}, "")) 4598 4599 pattern_ABitOfEverythingService_Echo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "example", "a_bit_of_everything", "echo", "value"}, "")) 4600 4601 pattern_ABitOfEverythingService_Echo_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "echo"}, "")) 4602 4603 pattern_ABitOfEverythingService_Echo_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "echo"}, "")) 4604 4605 pattern_ABitOfEverythingService_DeepPathEcho_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "deep_path", "single_nested.name"}, "")) 4606 4607 pattern_ABitOfEverythingService_Timeout_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "timeout"}, "")) 4608 4609 pattern_ABitOfEverythingService_ErrorWithDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "errorwithdetails"}, "")) 4610 4611 pattern_ABitOfEverythingService_GetMessageWithBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "withbody", "id"}, "")) 4612 4613 pattern_ABitOfEverythingService_PostWithEmptyBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "example", "postwithemptybody", "name"}, "")) 4614 4615 pattern_ABitOfEverythingService_CheckGetQueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "a_bit_of_everything", "params", "get", "single_nested.name"}, "")) 4616 4617 pattern_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"v1", "example", "a_bit_of_everything", "params", "get", "nested_enum", "single_nested.ok"}, "")) 4618 4619 pattern_ABitOfEverythingService_CheckPostQueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "a_bit_of_everything", "params", "post", "string_value"}, "")) 4620 4621 pattern_ABitOfEverythingService_OverwriteRequestContentType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "overwriterequestcontenttype"}, "")) 4622 4623 pattern_ABitOfEverythingService_OverwriteResponseContentType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "overwriteresponsecontenttype"}, "")) 4624 4625 pattern_ABitOfEverythingService_CheckExternalPathEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"v2", "value"}, "check")) 4626 4627 pattern_ABitOfEverythingService_CheckExternalNestedPathEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"v3", "value"}, "check")) 4628 4629 pattern_ABitOfEverythingService_CheckStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "checkStatus"}, "")) 4630 4631 pattern_ABitOfEverythingService_Exists_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "")) 4632 4633 pattern_ABitOfEverythingService_CustomOptionsRequest_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "")) 4634 4635 pattern_ABitOfEverythingService_TraceRequest_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "example", "a_bit_of_everything", "uuid"}, "")) 4636 4637 pattern_ABitOfEverythingService_PostOneofEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "oneofenum"}, "")) 4638 4639 pattern_ABitOfEverythingService_PostRequiredMessageType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "requiredmessagetype"}, "")) 4640 ) 4641 4642 var ( 4643 forward_ABitOfEverythingService_Create_0 = runtime.ForwardResponseMessage 4644 4645 forward_ABitOfEverythingService_CreateBody_0 = runtime.ForwardResponseMessage 4646 4647 forward_ABitOfEverythingService_CreateBook_0 = runtime.ForwardResponseMessage 4648 4649 forward_ABitOfEverythingService_UpdateBook_0 = runtime.ForwardResponseMessage 4650 4651 forward_ABitOfEverythingService_Lookup_0 = runtime.ForwardResponseMessage 4652 4653 forward_ABitOfEverythingService_Custom_0 = runtime.ForwardResponseMessage 4654 4655 forward_ABitOfEverythingService_DoubleColon_0 = runtime.ForwardResponseMessage 4656 4657 forward_ABitOfEverythingService_Update_0 = runtime.ForwardResponseMessage 4658 4659 forward_ABitOfEverythingService_UpdateV2_0 = runtime.ForwardResponseMessage 4660 4661 forward_ABitOfEverythingService_UpdateV2_1 = runtime.ForwardResponseMessage 4662 4663 forward_ABitOfEverythingService_UpdateV2_2 = runtime.ForwardResponseMessage 4664 4665 forward_ABitOfEverythingService_Delete_0 = runtime.ForwardResponseMessage 4666 4667 forward_ABitOfEverythingService_GetQuery_0 = runtime.ForwardResponseMessage 4668 4669 forward_ABitOfEverythingService_GetRepeatedQuery_0 = runtime.ForwardResponseMessage 4670 4671 forward_ABitOfEverythingService_Echo_0 = runtime.ForwardResponseMessage 4672 4673 forward_ABitOfEverythingService_Echo_1 = runtime.ForwardResponseMessage 4674 4675 forward_ABitOfEverythingService_Echo_2 = runtime.ForwardResponseMessage 4676 4677 forward_ABitOfEverythingService_DeepPathEcho_0 = runtime.ForwardResponseMessage 4678 4679 forward_ABitOfEverythingService_Timeout_0 = runtime.ForwardResponseMessage 4680 4681 forward_ABitOfEverythingService_ErrorWithDetails_0 = runtime.ForwardResponseMessage 4682 4683 forward_ABitOfEverythingService_GetMessageWithBody_0 = runtime.ForwardResponseMessage 4684 4685 forward_ABitOfEverythingService_PostWithEmptyBody_0 = runtime.ForwardResponseMessage 4686 4687 forward_ABitOfEverythingService_CheckGetQueryParams_0 = runtime.ForwardResponseMessage 4688 4689 forward_ABitOfEverythingService_CheckNestedEnumGetQueryParams_0 = runtime.ForwardResponseMessage 4690 4691 forward_ABitOfEverythingService_CheckPostQueryParams_0 = runtime.ForwardResponseMessage 4692 4693 forward_ABitOfEverythingService_OverwriteRequestContentType_0 = runtime.ForwardResponseMessage 4694 4695 forward_ABitOfEverythingService_OverwriteResponseContentType_0 = runtime.ForwardResponseMessage 4696 4697 forward_ABitOfEverythingService_CheckExternalPathEnum_0 = runtime.ForwardResponseMessage 4698 4699 forward_ABitOfEverythingService_CheckExternalNestedPathEnum_0 = runtime.ForwardResponseMessage 4700 4701 forward_ABitOfEverythingService_CheckStatus_0 = runtime.ForwardResponseMessage 4702 4703 forward_ABitOfEverythingService_Exists_0 = runtime.ForwardResponseMessage 4704 4705 forward_ABitOfEverythingService_CustomOptionsRequest_0 = runtime.ForwardResponseMessage 4706 4707 forward_ABitOfEverythingService_TraceRequest_0 = runtime.ForwardResponseMessage 4708 4709 forward_ABitOfEverythingService_PostOneofEnum_0 = runtime.ForwardResponseMessage 4710 4711 forward_ABitOfEverythingService_PostRequiredMessageType_0 = runtime.ForwardResponseMessage 4712 ) 4713 4714 // RegisterCamelCaseServiceNameHandlerFromEndpoint is same as RegisterCamelCaseServiceNameHandler but 4715 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 4716 func RegisterCamelCaseServiceNameHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 4717 conn, err := grpc.DialContext(ctx, endpoint, opts...) 4718 if err != nil { 4719 return err 4720 } 4721 defer func() { 4722 if err != nil { 4723 if cerr := conn.Close(); cerr != nil { 4724 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 4725 } 4726 return 4727 } 4728 go func() { 4729 <-ctx.Done() 4730 if cerr := conn.Close(); cerr != nil { 4731 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 4732 } 4733 }() 4734 }() 4735 4736 return RegisterCamelCaseServiceNameHandler(ctx, mux, conn) 4737 } 4738 4739 // RegisterCamelCaseServiceNameHandler registers the http handlers for service CamelCaseServiceName to "mux". 4740 // The handlers forward requests to the grpc endpoint over "conn". 4741 func RegisterCamelCaseServiceNameHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 4742 return RegisterCamelCaseServiceNameHandlerClient(ctx, mux, NewCamelCaseServiceNameClient(conn)) 4743 } 4744 4745 // RegisterCamelCaseServiceNameHandlerClient registers the http handlers for service CamelCaseServiceName 4746 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "CamelCaseServiceNameClient". 4747 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "CamelCaseServiceNameClient" 4748 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 4749 // "CamelCaseServiceNameClient" to call the correct interceptors. 4750 func RegisterCamelCaseServiceNameHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CamelCaseServiceNameClient) error { 4751 4752 mux.Handle("GET", pattern_CamelCaseServiceName_Empty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4753 ctx, cancel := context.WithCancel(req.Context()) 4754 defer cancel() 4755 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4756 var err error 4757 var annotatedContext context.Context 4758 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.CamelCaseServiceName/Empty", runtime.WithHTTPPathPattern("/v2/example/empty")) 4759 if err != nil { 4760 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4761 return 4762 } 4763 resp, md, err := request_CamelCaseServiceName_Empty_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4764 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4765 if err != nil { 4766 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4767 return 4768 } 4769 4770 forward_CamelCaseServiceName_Empty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4771 4772 }) 4773 4774 return nil 4775 } 4776 4777 var ( 4778 pattern_CamelCaseServiceName_Empty_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "example", "empty"}, "")) 4779 ) 4780 4781 var ( 4782 forward_CamelCaseServiceName_Empty_0 = runtime.ForwardResponseMessage 4783 ) 4784 4785 // RegisterSnakeEnumServiceHandlerFromEndpoint is same as RegisterSnakeEnumServiceHandler but 4786 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 4787 func RegisterSnakeEnumServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 4788 conn, err := grpc.DialContext(ctx, endpoint, opts...) 4789 if err != nil { 4790 return err 4791 } 4792 defer func() { 4793 if err != nil { 4794 if cerr := conn.Close(); cerr != nil { 4795 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 4796 } 4797 return 4798 } 4799 go func() { 4800 <-ctx.Done() 4801 if cerr := conn.Close(); cerr != nil { 4802 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 4803 } 4804 }() 4805 }() 4806 4807 return RegisterSnakeEnumServiceHandler(ctx, mux, conn) 4808 } 4809 4810 // RegisterSnakeEnumServiceHandler registers the http handlers for service SnakeEnumService to "mux". 4811 // The handlers forward requests to the grpc endpoint over "conn". 4812 func RegisterSnakeEnumServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 4813 return RegisterSnakeEnumServiceHandlerClient(ctx, mux, NewSnakeEnumServiceClient(conn)) 4814 } 4815 4816 // RegisterSnakeEnumServiceHandlerClient registers the http handlers for service SnakeEnumService 4817 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SnakeEnumServiceClient". 4818 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SnakeEnumServiceClient" 4819 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 4820 // "SnakeEnumServiceClient" to call the correct interceptors. 4821 func RegisterSnakeEnumServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SnakeEnumServiceClient) error { 4822 4823 mux.Handle("GET", pattern_SnakeEnumService_SnakeEnum_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 4824 ctx, cancel := context.WithCancel(req.Context()) 4825 defer cancel() 4826 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 4827 var err error 4828 var annotatedContext context.Context 4829 annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.SnakeEnumService/SnakeEnum", runtime.WithHTTPPathPattern("/v1/example/snake/{who}/{what}/{where}")) 4830 if err != nil { 4831 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 4832 return 4833 } 4834 resp, md, err := request_SnakeEnumService_SnakeEnum_0(annotatedContext, inboundMarshaler, client, req, pathParams) 4835 annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) 4836 if err != nil { 4837 runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) 4838 return 4839 } 4840 4841 forward_SnakeEnumService_SnakeEnum_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 4842 4843 }) 4844 4845 return nil 4846 } 4847 4848 var ( 4849 pattern_SnakeEnumService_SnakeEnum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "example", "snake", "who", "what", "where"}, "")) 4850 ) 4851 4852 var ( 4853 forward_SnakeEnumService_SnakeEnum_0 = runtime.ForwardResponseMessage 4854 )