1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ec2query 4 5import ( 6 "bytes" 7 "context" 8 "encoding/base64" 9 "encoding/xml" 10 "fmt" 11 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 12 "github.com/aws/aws-sdk-go-v2/aws/protocol/ec2query" 13 "github.com/aws/aws-sdk-go-v2/internal/protocoltest/ec2query/types" 14 smithy "github.com/aws/smithy-go" 15 smithyxml "github.com/aws/smithy-go/encoding/xml" 16 smithyio "github.com/aws/smithy-go/io" 17 "github.com/aws/smithy-go/middleware" 18 "github.com/aws/smithy-go/ptr" 19 smithytime "github.com/aws/smithy-go/time" 20 smithyhttp "github.com/aws/smithy-go/transport/http" 21 "io" 22 "io/ioutil" 23 "strconv" 24 "strings" 25 "time" 26) 27 28type awsEc2query_deserializeOpEmptyInputAndEmptyOutput struct { 29} 30 31func (*awsEc2query_deserializeOpEmptyInputAndEmptyOutput) ID() string { 32 return "OperationDeserializer" 33} 34 35func (m *awsEc2query_deserializeOpEmptyInputAndEmptyOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 36 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 37) { 38 out, metadata, err = next.HandleDeserialize(ctx, in) 39 if err != nil { 40 return out, metadata, err 41 } 42 43 response, ok := out.RawResponse.(*smithyhttp.Response) 44 if !ok { 45 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 46 } 47 48 if response.StatusCode < 200 || response.StatusCode >= 300 { 49 return out, metadata, awsEc2query_deserializeOpErrorEmptyInputAndEmptyOutput(response, &metadata) 50 } 51 output := &EmptyInputAndEmptyOutputOutput{} 52 out.Result = output 53 54 var buff [1024]byte 55 ringBuffer := smithyio.NewRingBuffer(buff[:]) 56 body := io.TeeReader(response.Body, ringBuffer) 57 rootDecoder := xml.NewDecoder(body) 58 t, err := smithyxml.FetchRootElement(rootDecoder) 59 if err == io.EOF { 60 return out, metadata, nil 61 } 62 if err != nil { 63 var snapshot bytes.Buffer 64 io.Copy(&snapshot, ringBuffer) 65 return out, metadata, &smithy.DeserializationError{ 66 Err: fmt.Errorf("failed to decode response body, %w", err), 67 Snapshot: snapshot.Bytes(), 68 } 69 } 70 71 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 72 err = awsEc2query_deserializeOpDocumentEmptyInputAndEmptyOutputOutput(&output, decoder) 73 if err != nil { 74 var snapshot bytes.Buffer 75 io.Copy(&snapshot, ringBuffer) 76 err = &smithy.DeserializationError{ 77 Err: fmt.Errorf("failed to decode response body, %w", err), 78 Snapshot: snapshot.Bytes(), 79 } 80 return out, metadata, err 81 } 82 83 return out, metadata, err 84} 85 86func awsEc2query_deserializeOpErrorEmptyInputAndEmptyOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 87 var errorBuffer bytes.Buffer 88 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 89 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 90 } 91 errorBody := bytes.NewReader(errorBuffer.Bytes()) 92 93 errorCode := "UnknownError" 94 errorMessage := errorCode 95 96 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 97 if err != nil { 98 return err 99 } 100 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 101 if len(errorComponents.Code) != 0 { 102 errorCode = errorComponents.Code 103 } 104 if len(errorComponents.Message) != 0 { 105 errorMessage = errorComponents.Message 106 } 107 errorBody.Seek(0, io.SeekStart) 108 switch { 109 default: 110 genericError := &smithy.GenericAPIError{ 111 Code: errorCode, 112 Message: errorMessage, 113 } 114 return genericError 115 116 } 117} 118 119type awsEc2query_deserializeOpEndpointOperation struct { 120} 121 122func (*awsEc2query_deserializeOpEndpointOperation) ID() string { 123 return "OperationDeserializer" 124} 125 126func (m *awsEc2query_deserializeOpEndpointOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 127 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 128) { 129 out, metadata, err = next.HandleDeserialize(ctx, in) 130 if err != nil { 131 return out, metadata, err 132 } 133 134 response, ok := out.RawResponse.(*smithyhttp.Response) 135 if !ok { 136 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 137 } 138 139 if response.StatusCode < 200 || response.StatusCode >= 300 { 140 return out, metadata, awsEc2query_deserializeOpErrorEndpointOperation(response, &metadata) 141 } 142 output := &EndpointOperationOutput{} 143 out.Result = output 144 145 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 146 return out, metadata, &smithy.DeserializationError{ 147 Err: fmt.Errorf("failed to discard response body, %w", err), 148 } 149 } 150 151 return out, metadata, err 152} 153 154func awsEc2query_deserializeOpErrorEndpointOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 155 var errorBuffer bytes.Buffer 156 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 157 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 158 } 159 errorBody := bytes.NewReader(errorBuffer.Bytes()) 160 161 errorCode := "UnknownError" 162 errorMessage := errorCode 163 164 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 165 if err != nil { 166 return err 167 } 168 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 169 if len(errorComponents.Code) != 0 { 170 errorCode = errorComponents.Code 171 } 172 if len(errorComponents.Message) != 0 { 173 errorMessage = errorComponents.Message 174 } 175 errorBody.Seek(0, io.SeekStart) 176 switch { 177 default: 178 genericError := &smithy.GenericAPIError{ 179 Code: errorCode, 180 Message: errorMessage, 181 } 182 return genericError 183 184 } 185} 186 187type awsEc2query_deserializeOpEndpointWithHostLabelOperation struct { 188} 189 190func (*awsEc2query_deserializeOpEndpointWithHostLabelOperation) ID() string { 191 return "OperationDeserializer" 192} 193 194func (m *awsEc2query_deserializeOpEndpointWithHostLabelOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 195 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 196) { 197 out, metadata, err = next.HandleDeserialize(ctx, in) 198 if err != nil { 199 return out, metadata, err 200 } 201 202 response, ok := out.RawResponse.(*smithyhttp.Response) 203 if !ok { 204 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 205 } 206 207 if response.StatusCode < 200 || response.StatusCode >= 300 { 208 return out, metadata, awsEc2query_deserializeOpErrorEndpointWithHostLabelOperation(response, &metadata) 209 } 210 output := &EndpointWithHostLabelOperationOutput{} 211 out.Result = output 212 213 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 214 return out, metadata, &smithy.DeserializationError{ 215 Err: fmt.Errorf("failed to discard response body, %w", err), 216 } 217 } 218 219 return out, metadata, err 220} 221 222func awsEc2query_deserializeOpErrorEndpointWithHostLabelOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 223 var errorBuffer bytes.Buffer 224 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 225 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 226 } 227 errorBody := bytes.NewReader(errorBuffer.Bytes()) 228 229 errorCode := "UnknownError" 230 errorMessage := errorCode 231 232 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 233 if err != nil { 234 return err 235 } 236 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 237 if len(errorComponents.Code) != 0 { 238 errorCode = errorComponents.Code 239 } 240 if len(errorComponents.Message) != 0 { 241 errorMessage = errorComponents.Message 242 } 243 errorBody.Seek(0, io.SeekStart) 244 switch { 245 default: 246 genericError := &smithy.GenericAPIError{ 247 Code: errorCode, 248 Message: errorMessage, 249 } 250 return genericError 251 252 } 253} 254 255type awsEc2query_deserializeOpGreetingWithErrors struct { 256} 257 258func (*awsEc2query_deserializeOpGreetingWithErrors) ID() string { 259 return "OperationDeserializer" 260} 261 262func (m *awsEc2query_deserializeOpGreetingWithErrors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 263 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 264) { 265 out, metadata, err = next.HandleDeserialize(ctx, in) 266 if err != nil { 267 return out, metadata, err 268 } 269 270 response, ok := out.RawResponse.(*smithyhttp.Response) 271 if !ok { 272 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 273 } 274 275 if response.StatusCode < 200 || response.StatusCode >= 300 { 276 return out, metadata, awsEc2query_deserializeOpErrorGreetingWithErrors(response, &metadata) 277 } 278 output := &GreetingWithErrorsOutput{} 279 out.Result = output 280 281 var buff [1024]byte 282 ringBuffer := smithyio.NewRingBuffer(buff[:]) 283 body := io.TeeReader(response.Body, ringBuffer) 284 rootDecoder := xml.NewDecoder(body) 285 t, err := smithyxml.FetchRootElement(rootDecoder) 286 if err == io.EOF { 287 return out, metadata, nil 288 } 289 if err != nil { 290 var snapshot bytes.Buffer 291 io.Copy(&snapshot, ringBuffer) 292 return out, metadata, &smithy.DeserializationError{ 293 Err: fmt.Errorf("failed to decode response body, %w", err), 294 Snapshot: snapshot.Bytes(), 295 } 296 } 297 298 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 299 err = awsEc2query_deserializeOpDocumentGreetingWithErrorsOutput(&output, decoder) 300 if err != nil { 301 var snapshot bytes.Buffer 302 io.Copy(&snapshot, ringBuffer) 303 err = &smithy.DeserializationError{ 304 Err: fmt.Errorf("failed to decode response body, %w", err), 305 Snapshot: snapshot.Bytes(), 306 } 307 return out, metadata, err 308 } 309 310 return out, metadata, err 311} 312 313func awsEc2query_deserializeOpErrorGreetingWithErrors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 314 var errorBuffer bytes.Buffer 315 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 316 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 317 } 318 errorBody := bytes.NewReader(errorBuffer.Bytes()) 319 320 errorCode := "UnknownError" 321 errorMessage := errorCode 322 323 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 324 if err != nil { 325 return err 326 } 327 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 328 if len(errorComponents.Code) != 0 { 329 errorCode = errorComponents.Code 330 } 331 if len(errorComponents.Message) != 0 { 332 errorMessage = errorComponents.Message 333 } 334 errorBody.Seek(0, io.SeekStart) 335 switch { 336 case strings.EqualFold("ComplexError", errorCode): 337 return awsEc2query_deserializeErrorComplexError(response, errorBody) 338 339 case strings.EqualFold("InvalidGreeting", errorCode): 340 return awsEc2query_deserializeErrorInvalidGreeting(response, errorBody) 341 342 default: 343 genericError := &smithy.GenericAPIError{ 344 Code: errorCode, 345 Message: errorMessage, 346 } 347 return genericError 348 349 } 350} 351 352type awsEc2query_deserializeOpIgnoresWrappingXmlName struct { 353} 354 355func (*awsEc2query_deserializeOpIgnoresWrappingXmlName) ID() string { 356 return "OperationDeserializer" 357} 358 359func (m *awsEc2query_deserializeOpIgnoresWrappingXmlName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 360 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 361) { 362 out, metadata, err = next.HandleDeserialize(ctx, in) 363 if err != nil { 364 return out, metadata, err 365 } 366 367 response, ok := out.RawResponse.(*smithyhttp.Response) 368 if !ok { 369 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 370 } 371 372 if response.StatusCode < 200 || response.StatusCode >= 300 { 373 return out, metadata, awsEc2query_deserializeOpErrorIgnoresWrappingXmlName(response, &metadata) 374 } 375 output := &IgnoresWrappingXmlNameOutput{} 376 out.Result = output 377 378 var buff [1024]byte 379 ringBuffer := smithyio.NewRingBuffer(buff[:]) 380 body := io.TeeReader(response.Body, ringBuffer) 381 rootDecoder := xml.NewDecoder(body) 382 t, err := smithyxml.FetchRootElement(rootDecoder) 383 if err == io.EOF { 384 return out, metadata, nil 385 } 386 if err != nil { 387 var snapshot bytes.Buffer 388 io.Copy(&snapshot, ringBuffer) 389 return out, metadata, &smithy.DeserializationError{ 390 Err: fmt.Errorf("failed to decode response body, %w", err), 391 Snapshot: snapshot.Bytes(), 392 } 393 } 394 395 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 396 err = awsEc2query_deserializeOpDocumentIgnoresWrappingXmlNameOutput(&output, decoder) 397 if err != nil { 398 var snapshot bytes.Buffer 399 io.Copy(&snapshot, ringBuffer) 400 err = &smithy.DeserializationError{ 401 Err: fmt.Errorf("failed to decode response body, %w", err), 402 Snapshot: snapshot.Bytes(), 403 } 404 return out, metadata, err 405 } 406 407 return out, metadata, err 408} 409 410func awsEc2query_deserializeOpErrorIgnoresWrappingXmlName(response *smithyhttp.Response, metadata *middleware.Metadata) error { 411 var errorBuffer bytes.Buffer 412 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 413 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 414 } 415 errorBody := bytes.NewReader(errorBuffer.Bytes()) 416 417 errorCode := "UnknownError" 418 errorMessage := errorCode 419 420 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 421 if err != nil { 422 return err 423 } 424 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 425 if len(errorComponents.Code) != 0 { 426 errorCode = errorComponents.Code 427 } 428 if len(errorComponents.Message) != 0 { 429 errorMessage = errorComponents.Message 430 } 431 errorBody.Seek(0, io.SeekStart) 432 switch { 433 default: 434 genericError := &smithy.GenericAPIError{ 435 Code: errorCode, 436 Message: errorMessage, 437 } 438 return genericError 439 440 } 441} 442 443type awsEc2query_deserializeOpNestedStructures struct { 444} 445 446func (*awsEc2query_deserializeOpNestedStructures) ID() string { 447 return "OperationDeserializer" 448} 449 450func (m *awsEc2query_deserializeOpNestedStructures) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 451 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 452) { 453 out, metadata, err = next.HandleDeserialize(ctx, in) 454 if err != nil { 455 return out, metadata, err 456 } 457 458 response, ok := out.RawResponse.(*smithyhttp.Response) 459 if !ok { 460 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 461 } 462 463 if response.StatusCode < 200 || response.StatusCode >= 300 { 464 return out, metadata, awsEc2query_deserializeOpErrorNestedStructures(response, &metadata) 465 } 466 output := &NestedStructuresOutput{} 467 out.Result = output 468 469 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 470 return out, metadata, &smithy.DeserializationError{ 471 Err: fmt.Errorf("failed to discard response body, %w", err), 472 } 473 } 474 475 return out, metadata, err 476} 477 478func awsEc2query_deserializeOpErrorNestedStructures(response *smithyhttp.Response, metadata *middleware.Metadata) error { 479 var errorBuffer bytes.Buffer 480 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 481 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 482 } 483 errorBody := bytes.NewReader(errorBuffer.Bytes()) 484 485 errorCode := "UnknownError" 486 errorMessage := errorCode 487 488 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 489 if err != nil { 490 return err 491 } 492 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 493 if len(errorComponents.Code) != 0 { 494 errorCode = errorComponents.Code 495 } 496 if len(errorComponents.Message) != 0 { 497 errorMessage = errorComponents.Message 498 } 499 errorBody.Seek(0, io.SeekStart) 500 switch { 501 default: 502 genericError := &smithy.GenericAPIError{ 503 Code: errorCode, 504 Message: errorMessage, 505 } 506 return genericError 507 508 } 509} 510 511type awsEc2query_deserializeOpNoInputAndOutput struct { 512} 513 514func (*awsEc2query_deserializeOpNoInputAndOutput) ID() string { 515 return "OperationDeserializer" 516} 517 518func (m *awsEc2query_deserializeOpNoInputAndOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 519 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 520) { 521 out, metadata, err = next.HandleDeserialize(ctx, in) 522 if err != nil { 523 return out, metadata, err 524 } 525 526 response, ok := out.RawResponse.(*smithyhttp.Response) 527 if !ok { 528 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 529 } 530 531 if response.StatusCode < 200 || response.StatusCode >= 300 { 532 return out, metadata, awsEc2query_deserializeOpErrorNoInputAndOutput(response, &metadata) 533 } 534 output := &NoInputAndOutputOutput{} 535 out.Result = output 536 537 var buff [1024]byte 538 ringBuffer := smithyio.NewRingBuffer(buff[:]) 539 body := io.TeeReader(response.Body, ringBuffer) 540 rootDecoder := xml.NewDecoder(body) 541 t, err := smithyxml.FetchRootElement(rootDecoder) 542 if err == io.EOF { 543 return out, metadata, nil 544 } 545 if err != nil { 546 var snapshot bytes.Buffer 547 io.Copy(&snapshot, ringBuffer) 548 return out, metadata, &smithy.DeserializationError{ 549 Err: fmt.Errorf("failed to decode response body, %w", err), 550 Snapshot: snapshot.Bytes(), 551 } 552 } 553 554 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 555 err = awsEc2query_deserializeOpDocumentNoInputAndOutputOutput(&output, decoder) 556 if err != nil { 557 var snapshot bytes.Buffer 558 io.Copy(&snapshot, ringBuffer) 559 err = &smithy.DeserializationError{ 560 Err: fmt.Errorf("failed to decode response body, %w", err), 561 Snapshot: snapshot.Bytes(), 562 } 563 return out, metadata, err 564 } 565 566 return out, metadata, err 567} 568 569func awsEc2query_deserializeOpErrorNoInputAndOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 570 var errorBuffer bytes.Buffer 571 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 572 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 573 } 574 errorBody := bytes.NewReader(errorBuffer.Bytes()) 575 576 errorCode := "UnknownError" 577 errorMessage := errorCode 578 579 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 580 if err != nil { 581 return err 582 } 583 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 584 if len(errorComponents.Code) != 0 { 585 errorCode = errorComponents.Code 586 } 587 if len(errorComponents.Message) != 0 { 588 errorMessage = errorComponents.Message 589 } 590 errorBody.Seek(0, io.SeekStart) 591 switch { 592 default: 593 genericError := &smithy.GenericAPIError{ 594 Code: errorCode, 595 Message: errorMessage, 596 } 597 return genericError 598 599 } 600} 601 602type awsEc2query_deserializeOpQueryIdempotencyTokenAutoFill struct { 603} 604 605func (*awsEc2query_deserializeOpQueryIdempotencyTokenAutoFill) ID() string { 606 return "OperationDeserializer" 607} 608 609func (m *awsEc2query_deserializeOpQueryIdempotencyTokenAutoFill) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 610 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 611) { 612 out, metadata, err = next.HandleDeserialize(ctx, in) 613 if err != nil { 614 return out, metadata, err 615 } 616 617 response, ok := out.RawResponse.(*smithyhttp.Response) 618 if !ok { 619 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 620 } 621 622 if response.StatusCode < 200 || response.StatusCode >= 300 { 623 return out, metadata, awsEc2query_deserializeOpErrorQueryIdempotencyTokenAutoFill(response, &metadata) 624 } 625 output := &QueryIdempotencyTokenAutoFillOutput{} 626 out.Result = output 627 628 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 629 return out, metadata, &smithy.DeserializationError{ 630 Err: fmt.Errorf("failed to discard response body, %w", err), 631 } 632 } 633 634 return out, metadata, err 635} 636 637func awsEc2query_deserializeOpErrorQueryIdempotencyTokenAutoFill(response *smithyhttp.Response, metadata *middleware.Metadata) error { 638 var errorBuffer bytes.Buffer 639 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 640 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 641 } 642 errorBody := bytes.NewReader(errorBuffer.Bytes()) 643 644 errorCode := "UnknownError" 645 errorMessage := errorCode 646 647 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 648 if err != nil { 649 return err 650 } 651 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 652 if len(errorComponents.Code) != 0 { 653 errorCode = errorComponents.Code 654 } 655 if len(errorComponents.Message) != 0 { 656 errorMessage = errorComponents.Message 657 } 658 errorBody.Seek(0, io.SeekStart) 659 switch { 660 default: 661 genericError := &smithy.GenericAPIError{ 662 Code: errorCode, 663 Message: errorMessage, 664 } 665 return genericError 666 667 } 668} 669 670type awsEc2query_deserializeOpQueryLists struct { 671} 672 673func (*awsEc2query_deserializeOpQueryLists) ID() string { 674 return "OperationDeserializer" 675} 676 677func (m *awsEc2query_deserializeOpQueryLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 678 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 679) { 680 out, metadata, err = next.HandleDeserialize(ctx, in) 681 if err != nil { 682 return out, metadata, err 683 } 684 685 response, ok := out.RawResponse.(*smithyhttp.Response) 686 if !ok { 687 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 688 } 689 690 if response.StatusCode < 200 || response.StatusCode >= 300 { 691 return out, metadata, awsEc2query_deserializeOpErrorQueryLists(response, &metadata) 692 } 693 output := &QueryListsOutput{} 694 out.Result = output 695 696 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 697 return out, metadata, &smithy.DeserializationError{ 698 Err: fmt.Errorf("failed to discard response body, %w", err), 699 } 700 } 701 702 return out, metadata, err 703} 704 705func awsEc2query_deserializeOpErrorQueryLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 706 var errorBuffer bytes.Buffer 707 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 708 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 709 } 710 errorBody := bytes.NewReader(errorBuffer.Bytes()) 711 712 errorCode := "UnknownError" 713 errorMessage := errorCode 714 715 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 716 if err != nil { 717 return err 718 } 719 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 720 if len(errorComponents.Code) != 0 { 721 errorCode = errorComponents.Code 722 } 723 if len(errorComponents.Message) != 0 { 724 errorMessage = errorComponents.Message 725 } 726 errorBody.Seek(0, io.SeekStart) 727 switch { 728 default: 729 genericError := &smithy.GenericAPIError{ 730 Code: errorCode, 731 Message: errorMessage, 732 } 733 return genericError 734 735 } 736} 737 738type awsEc2query_deserializeOpQueryTimestamps struct { 739} 740 741func (*awsEc2query_deserializeOpQueryTimestamps) ID() string { 742 return "OperationDeserializer" 743} 744 745func (m *awsEc2query_deserializeOpQueryTimestamps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 746 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 747) { 748 out, metadata, err = next.HandleDeserialize(ctx, in) 749 if err != nil { 750 return out, metadata, err 751 } 752 753 response, ok := out.RawResponse.(*smithyhttp.Response) 754 if !ok { 755 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 756 } 757 758 if response.StatusCode < 200 || response.StatusCode >= 300 { 759 return out, metadata, awsEc2query_deserializeOpErrorQueryTimestamps(response, &metadata) 760 } 761 output := &QueryTimestampsOutput{} 762 out.Result = output 763 764 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 765 return out, metadata, &smithy.DeserializationError{ 766 Err: fmt.Errorf("failed to discard response body, %w", err), 767 } 768 } 769 770 return out, metadata, err 771} 772 773func awsEc2query_deserializeOpErrorQueryTimestamps(response *smithyhttp.Response, metadata *middleware.Metadata) error { 774 var errorBuffer bytes.Buffer 775 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 776 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 777 } 778 errorBody := bytes.NewReader(errorBuffer.Bytes()) 779 780 errorCode := "UnknownError" 781 errorMessage := errorCode 782 783 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 784 if err != nil { 785 return err 786 } 787 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 788 if len(errorComponents.Code) != 0 { 789 errorCode = errorComponents.Code 790 } 791 if len(errorComponents.Message) != 0 { 792 errorMessage = errorComponents.Message 793 } 794 errorBody.Seek(0, io.SeekStart) 795 switch { 796 default: 797 genericError := &smithy.GenericAPIError{ 798 Code: errorCode, 799 Message: errorMessage, 800 } 801 return genericError 802 803 } 804} 805 806type awsEc2query_deserializeOpRecursiveXmlShapes struct { 807} 808 809func (*awsEc2query_deserializeOpRecursiveXmlShapes) ID() string { 810 return "OperationDeserializer" 811} 812 813func (m *awsEc2query_deserializeOpRecursiveXmlShapes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 814 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 815) { 816 out, metadata, err = next.HandleDeserialize(ctx, in) 817 if err != nil { 818 return out, metadata, err 819 } 820 821 response, ok := out.RawResponse.(*smithyhttp.Response) 822 if !ok { 823 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 824 } 825 826 if response.StatusCode < 200 || response.StatusCode >= 300 { 827 return out, metadata, awsEc2query_deserializeOpErrorRecursiveXmlShapes(response, &metadata) 828 } 829 output := &RecursiveXmlShapesOutput{} 830 out.Result = output 831 832 var buff [1024]byte 833 ringBuffer := smithyio.NewRingBuffer(buff[:]) 834 body := io.TeeReader(response.Body, ringBuffer) 835 rootDecoder := xml.NewDecoder(body) 836 t, err := smithyxml.FetchRootElement(rootDecoder) 837 if err == io.EOF { 838 return out, metadata, nil 839 } 840 if err != nil { 841 var snapshot bytes.Buffer 842 io.Copy(&snapshot, ringBuffer) 843 return out, metadata, &smithy.DeserializationError{ 844 Err: fmt.Errorf("failed to decode response body, %w", err), 845 Snapshot: snapshot.Bytes(), 846 } 847 } 848 849 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 850 err = awsEc2query_deserializeOpDocumentRecursiveXmlShapesOutput(&output, decoder) 851 if err != nil { 852 var snapshot bytes.Buffer 853 io.Copy(&snapshot, ringBuffer) 854 err = &smithy.DeserializationError{ 855 Err: fmt.Errorf("failed to decode response body, %w", err), 856 Snapshot: snapshot.Bytes(), 857 } 858 return out, metadata, err 859 } 860 861 return out, metadata, err 862} 863 864func awsEc2query_deserializeOpErrorRecursiveXmlShapes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 865 var errorBuffer bytes.Buffer 866 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 867 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 868 } 869 errorBody := bytes.NewReader(errorBuffer.Bytes()) 870 871 errorCode := "UnknownError" 872 errorMessage := errorCode 873 874 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 875 if err != nil { 876 return err 877 } 878 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 879 if len(errorComponents.Code) != 0 { 880 errorCode = errorComponents.Code 881 } 882 if len(errorComponents.Message) != 0 { 883 errorMessage = errorComponents.Message 884 } 885 errorBody.Seek(0, io.SeekStart) 886 switch { 887 default: 888 genericError := &smithy.GenericAPIError{ 889 Code: errorCode, 890 Message: errorMessage, 891 } 892 return genericError 893 894 } 895} 896 897type awsEc2query_deserializeOpSimpleInputParams struct { 898} 899 900func (*awsEc2query_deserializeOpSimpleInputParams) ID() string { 901 return "OperationDeserializer" 902} 903 904func (m *awsEc2query_deserializeOpSimpleInputParams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 905 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 906) { 907 out, metadata, err = next.HandleDeserialize(ctx, in) 908 if err != nil { 909 return out, metadata, err 910 } 911 912 response, ok := out.RawResponse.(*smithyhttp.Response) 913 if !ok { 914 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 915 } 916 917 if response.StatusCode < 200 || response.StatusCode >= 300 { 918 return out, metadata, awsEc2query_deserializeOpErrorSimpleInputParams(response, &metadata) 919 } 920 output := &SimpleInputParamsOutput{} 921 out.Result = output 922 923 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 924 return out, metadata, &smithy.DeserializationError{ 925 Err: fmt.Errorf("failed to discard response body, %w", err), 926 } 927 } 928 929 return out, metadata, err 930} 931 932func awsEc2query_deserializeOpErrorSimpleInputParams(response *smithyhttp.Response, metadata *middleware.Metadata) error { 933 var errorBuffer bytes.Buffer 934 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 935 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 936 } 937 errorBody := bytes.NewReader(errorBuffer.Bytes()) 938 939 errorCode := "UnknownError" 940 errorMessage := errorCode 941 942 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 943 if err != nil { 944 return err 945 } 946 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 947 if len(errorComponents.Code) != 0 { 948 errorCode = errorComponents.Code 949 } 950 if len(errorComponents.Message) != 0 { 951 errorMessage = errorComponents.Message 952 } 953 errorBody.Seek(0, io.SeekStart) 954 switch { 955 default: 956 genericError := &smithy.GenericAPIError{ 957 Code: errorCode, 958 Message: errorMessage, 959 } 960 return genericError 961 962 } 963} 964 965type awsEc2query_deserializeOpSimpleScalarXmlProperties struct { 966} 967 968func (*awsEc2query_deserializeOpSimpleScalarXmlProperties) ID() string { 969 return "OperationDeserializer" 970} 971 972func (m *awsEc2query_deserializeOpSimpleScalarXmlProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 973 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 974) { 975 out, metadata, err = next.HandleDeserialize(ctx, in) 976 if err != nil { 977 return out, metadata, err 978 } 979 980 response, ok := out.RawResponse.(*smithyhttp.Response) 981 if !ok { 982 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 983 } 984 985 if response.StatusCode < 200 || response.StatusCode >= 300 { 986 return out, metadata, awsEc2query_deserializeOpErrorSimpleScalarXmlProperties(response, &metadata) 987 } 988 output := &SimpleScalarXmlPropertiesOutput{} 989 out.Result = output 990 991 var buff [1024]byte 992 ringBuffer := smithyio.NewRingBuffer(buff[:]) 993 body := io.TeeReader(response.Body, ringBuffer) 994 rootDecoder := xml.NewDecoder(body) 995 t, err := smithyxml.FetchRootElement(rootDecoder) 996 if err == io.EOF { 997 return out, metadata, nil 998 } 999 if err != nil { 1000 var snapshot bytes.Buffer 1001 io.Copy(&snapshot, ringBuffer) 1002 return out, metadata, &smithy.DeserializationError{ 1003 Err: fmt.Errorf("failed to decode response body, %w", err), 1004 Snapshot: snapshot.Bytes(), 1005 } 1006 } 1007 1008 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1009 err = awsEc2query_deserializeOpDocumentSimpleScalarXmlPropertiesOutput(&output, decoder) 1010 if err != nil { 1011 var snapshot bytes.Buffer 1012 io.Copy(&snapshot, ringBuffer) 1013 err = &smithy.DeserializationError{ 1014 Err: fmt.Errorf("failed to decode response body, %w", err), 1015 Snapshot: snapshot.Bytes(), 1016 } 1017 return out, metadata, err 1018 } 1019 1020 return out, metadata, err 1021} 1022 1023func awsEc2query_deserializeOpErrorSimpleScalarXmlProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1024 var errorBuffer bytes.Buffer 1025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1027 } 1028 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1029 1030 errorCode := "UnknownError" 1031 errorMessage := errorCode 1032 1033 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1034 if err != nil { 1035 return err 1036 } 1037 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1038 if len(errorComponents.Code) != 0 { 1039 errorCode = errorComponents.Code 1040 } 1041 if len(errorComponents.Message) != 0 { 1042 errorMessage = errorComponents.Message 1043 } 1044 errorBody.Seek(0, io.SeekStart) 1045 switch { 1046 default: 1047 genericError := &smithy.GenericAPIError{ 1048 Code: errorCode, 1049 Message: errorMessage, 1050 } 1051 return genericError 1052 1053 } 1054} 1055 1056type awsEc2query_deserializeOpXmlBlobs struct { 1057} 1058 1059func (*awsEc2query_deserializeOpXmlBlobs) ID() string { 1060 return "OperationDeserializer" 1061} 1062 1063func (m *awsEc2query_deserializeOpXmlBlobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1064 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1065) { 1066 out, metadata, err = next.HandleDeserialize(ctx, in) 1067 if err != nil { 1068 return out, metadata, err 1069 } 1070 1071 response, ok := out.RawResponse.(*smithyhttp.Response) 1072 if !ok { 1073 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1074 } 1075 1076 if response.StatusCode < 200 || response.StatusCode >= 300 { 1077 return out, metadata, awsEc2query_deserializeOpErrorXmlBlobs(response, &metadata) 1078 } 1079 output := &XmlBlobsOutput{} 1080 out.Result = output 1081 1082 var buff [1024]byte 1083 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1084 body := io.TeeReader(response.Body, ringBuffer) 1085 rootDecoder := xml.NewDecoder(body) 1086 t, err := smithyxml.FetchRootElement(rootDecoder) 1087 if err == io.EOF { 1088 return out, metadata, nil 1089 } 1090 if err != nil { 1091 var snapshot bytes.Buffer 1092 io.Copy(&snapshot, ringBuffer) 1093 return out, metadata, &smithy.DeserializationError{ 1094 Err: fmt.Errorf("failed to decode response body, %w", err), 1095 Snapshot: snapshot.Bytes(), 1096 } 1097 } 1098 1099 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1100 err = awsEc2query_deserializeOpDocumentXmlBlobsOutput(&output, decoder) 1101 if err != nil { 1102 var snapshot bytes.Buffer 1103 io.Copy(&snapshot, ringBuffer) 1104 err = &smithy.DeserializationError{ 1105 Err: fmt.Errorf("failed to decode response body, %w", err), 1106 Snapshot: snapshot.Bytes(), 1107 } 1108 return out, metadata, err 1109 } 1110 1111 return out, metadata, err 1112} 1113 1114func awsEc2query_deserializeOpErrorXmlBlobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1115 var errorBuffer bytes.Buffer 1116 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1117 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1118 } 1119 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1120 1121 errorCode := "UnknownError" 1122 errorMessage := errorCode 1123 1124 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1125 if err != nil { 1126 return err 1127 } 1128 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1129 if len(errorComponents.Code) != 0 { 1130 errorCode = errorComponents.Code 1131 } 1132 if len(errorComponents.Message) != 0 { 1133 errorMessage = errorComponents.Message 1134 } 1135 errorBody.Seek(0, io.SeekStart) 1136 switch { 1137 default: 1138 genericError := &smithy.GenericAPIError{ 1139 Code: errorCode, 1140 Message: errorMessage, 1141 } 1142 return genericError 1143 1144 } 1145} 1146 1147type awsEc2query_deserializeOpXmlEmptyBlobs struct { 1148} 1149 1150func (*awsEc2query_deserializeOpXmlEmptyBlobs) ID() string { 1151 return "OperationDeserializer" 1152} 1153 1154func (m *awsEc2query_deserializeOpXmlEmptyBlobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1155 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1156) { 1157 out, metadata, err = next.HandleDeserialize(ctx, in) 1158 if err != nil { 1159 return out, metadata, err 1160 } 1161 1162 response, ok := out.RawResponse.(*smithyhttp.Response) 1163 if !ok { 1164 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1165 } 1166 1167 if response.StatusCode < 200 || response.StatusCode >= 300 { 1168 return out, metadata, awsEc2query_deserializeOpErrorXmlEmptyBlobs(response, &metadata) 1169 } 1170 output := &XmlEmptyBlobsOutput{} 1171 out.Result = output 1172 1173 var buff [1024]byte 1174 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1175 body := io.TeeReader(response.Body, ringBuffer) 1176 rootDecoder := xml.NewDecoder(body) 1177 t, err := smithyxml.FetchRootElement(rootDecoder) 1178 if err == io.EOF { 1179 return out, metadata, nil 1180 } 1181 if err != nil { 1182 var snapshot bytes.Buffer 1183 io.Copy(&snapshot, ringBuffer) 1184 return out, metadata, &smithy.DeserializationError{ 1185 Err: fmt.Errorf("failed to decode response body, %w", err), 1186 Snapshot: snapshot.Bytes(), 1187 } 1188 } 1189 1190 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1191 err = awsEc2query_deserializeOpDocumentXmlEmptyBlobsOutput(&output, decoder) 1192 if err != nil { 1193 var snapshot bytes.Buffer 1194 io.Copy(&snapshot, ringBuffer) 1195 err = &smithy.DeserializationError{ 1196 Err: fmt.Errorf("failed to decode response body, %w", err), 1197 Snapshot: snapshot.Bytes(), 1198 } 1199 return out, metadata, err 1200 } 1201 1202 return out, metadata, err 1203} 1204 1205func awsEc2query_deserializeOpErrorXmlEmptyBlobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1206 var errorBuffer bytes.Buffer 1207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1209 } 1210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1211 1212 errorCode := "UnknownError" 1213 errorMessage := errorCode 1214 1215 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1216 if err != nil { 1217 return err 1218 } 1219 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1220 if len(errorComponents.Code) != 0 { 1221 errorCode = errorComponents.Code 1222 } 1223 if len(errorComponents.Message) != 0 { 1224 errorMessage = errorComponents.Message 1225 } 1226 errorBody.Seek(0, io.SeekStart) 1227 switch { 1228 default: 1229 genericError := &smithy.GenericAPIError{ 1230 Code: errorCode, 1231 Message: errorMessage, 1232 } 1233 return genericError 1234 1235 } 1236} 1237 1238type awsEc2query_deserializeOpXmlEmptyLists struct { 1239} 1240 1241func (*awsEc2query_deserializeOpXmlEmptyLists) ID() string { 1242 return "OperationDeserializer" 1243} 1244 1245func (m *awsEc2query_deserializeOpXmlEmptyLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1246 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1247) { 1248 out, metadata, err = next.HandleDeserialize(ctx, in) 1249 if err != nil { 1250 return out, metadata, err 1251 } 1252 1253 response, ok := out.RawResponse.(*smithyhttp.Response) 1254 if !ok { 1255 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1256 } 1257 1258 if response.StatusCode < 200 || response.StatusCode >= 300 { 1259 return out, metadata, awsEc2query_deserializeOpErrorXmlEmptyLists(response, &metadata) 1260 } 1261 output := &XmlEmptyListsOutput{} 1262 out.Result = output 1263 1264 var buff [1024]byte 1265 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1266 body := io.TeeReader(response.Body, ringBuffer) 1267 rootDecoder := xml.NewDecoder(body) 1268 t, err := smithyxml.FetchRootElement(rootDecoder) 1269 if err == io.EOF { 1270 return out, metadata, nil 1271 } 1272 if err != nil { 1273 var snapshot bytes.Buffer 1274 io.Copy(&snapshot, ringBuffer) 1275 return out, metadata, &smithy.DeserializationError{ 1276 Err: fmt.Errorf("failed to decode response body, %w", err), 1277 Snapshot: snapshot.Bytes(), 1278 } 1279 } 1280 1281 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1282 err = awsEc2query_deserializeOpDocumentXmlEmptyListsOutput(&output, decoder) 1283 if err != nil { 1284 var snapshot bytes.Buffer 1285 io.Copy(&snapshot, ringBuffer) 1286 err = &smithy.DeserializationError{ 1287 Err: fmt.Errorf("failed to decode response body, %w", err), 1288 Snapshot: snapshot.Bytes(), 1289 } 1290 return out, metadata, err 1291 } 1292 1293 return out, metadata, err 1294} 1295 1296func awsEc2query_deserializeOpErrorXmlEmptyLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1297 var errorBuffer bytes.Buffer 1298 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1299 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1300 } 1301 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1302 1303 errorCode := "UnknownError" 1304 errorMessage := errorCode 1305 1306 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1307 if err != nil { 1308 return err 1309 } 1310 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1311 if len(errorComponents.Code) != 0 { 1312 errorCode = errorComponents.Code 1313 } 1314 if len(errorComponents.Message) != 0 { 1315 errorMessage = errorComponents.Message 1316 } 1317 errorBody.Seek(0, io.SeekStart) 1318 switch { 1319 default: 1320 genericError := &smithy.GenericAPIError{ 1321 Code: errorCode, 1322 Message: errorMessage, 1323 } 1324 return genericError 1325 1326 } 1327} 1328 1329type awsEc2query_deserializeOpXmlEnums struct { 1330} 1331 1332func (*awsEc2query_deserializeOpXmlEnums) ID() string { 1333 return "OperationDeserializer" 1334} 1335 1336func (m *awsEc2query_deserializeOpXmlEnums) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1337 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1338) { 1339 out, metadata, err = next.HandleDeserialize(ctx, in) 1340 if err != nil { 1341 return out, metadata, err 1342 } 1343 1344 response, ok := out.RawResponse.(*smithyhttp.Response) 1345 if !ok { 1346 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1347 } 1348 1349 if response.StatusCode < 200 || response.StatusCode >= 300 { 1350 return out, metadata, awsEc2query_deserializeOpErrorXmlEnums(response, &metadata) 1351 } 1352 output := &XmlEnumsOutput{} 1353 out.Result = output 1354 1355 var buff [1024]byte 1356 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1357 body := io.TeeReader(response.Body, ringBuffer) 1358 rootDecoder := xml.NewDecoder(body) 1359 t, err := smithyxml.FetchRootElement(rootDecoder) 1360 if err == io.EOF { 1361 return out, metadata, nil 1362 } 1363 if err != nil { 1364 var snapshot bytes.Buffer 1365 io.Copy(&snapshot, ringBuffer) 1366 return out, metadata, &smithy.DeserializationError{ 1367 Err: fmt.Errorf("failed to decode response body, %w", err), 1368 Snapshot: snapshot.Bytes(), 1369 } 1370 } 1371 1372 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1373 err = awsEc2query_deserializeOpDocumentXmlEnumsOutput(&output, decoder) 1374 if err != nil { 1375 var snapshot bytes.Buffer 1376 io.Copy(&snapshot, ringBuffer) 1377 err = &smithy.DeserializationError{ 1378 Err: fmt.Errorf("failed to decode response body, %w", err), 1379 Snapshot: snapshot.Bytes(), 1380 } 1381 return out, metadata, err 1382 } 1383 1384 return out, metadata, err 1385} 1386 1387func awsEc2query_deserializeOpErrorXmlEnums(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1388 var errorBuffer bytes.Buffer 1389 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1390 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1391 } 1392 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1393 1394 errorCode := "UnknownError" 1395 errorMessage := errorCode 1396 1397 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1398 if err != nil { 1399 return err 1400 } 1401 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1402 if len(errorComponents.Code) != 0 { 1403 errorCode = errorComponents.Code 1404 } 1405 if len(errorComponents.Message) != 0 { 1406 errorMessage = errorComponents.Message 1407 } 1408 errorBody.Seek(0, io.SeekStart) 1409 switch { 1410 default: 1411 genericError := &smithy.GenericAPIError{ 1412 Code: errorCode, 1413 Message: errorMessage, 1414 } 1415 return genericError 1416 1417 } 1418} 1419 1420type awsEc2query_deserializeOpXmlLists struct { 1421} 1422 1423func (*awsEc2query_deserializeOpXmlLists) ID() string { 1424 return "OperationDeserializer" 1425} 1426 1427func (m *awsEc2query_deserializeOpXmlLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1428 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1429) { 1430 out, metadata, err = next.HandleDeserialize(ctx, in) 1431 if err != nil { 1432 return out, metadata, err 1433 } 1434 1435 response, ok := out.RawResponse.(*smithyhttp.Response) 1436 if !ok { 1437 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1438 } 1439 1440 if response.StatusCode < 200 || response.StatusCode >= 300 { 1441 return out, metadata, awsEc2query_deserializeOpErrorXmlLists(response, &metadata) 1442 } 1443 output := &XmlListsOutput{} 1444 out.Result = output 1445 1446 var buff [1024]byte 1447 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1448 body := io.TeeReader(response.Body, ringBuffer) 1449 rootDecoder := xml.NewDecoder(body) 1450 t, err := smithyxml.FetchRootElement(rootDecoder) 1451 if err == io.EOF { 1452 return out, metadata, nil 1453 } 1454 if err != nil { 1455 var snapshot bytes.Buffer 1456 io.Copy(&snapshot, ringBuffer) 1457 return out, metadata, &smithy.DeserializationError{ 1458 Err: fmt.Errorf("failed to decode response body, %w", err), 1459 Snapshot: snapshot.Bytes(), 1460 } 1461 } 1462 1463 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1464 err = awsEc2query_deserializeOpDocumentXmlListsOutput(&output, decoder) 1465 if err != nil { 1466 var snapshot bytes.Buffer 1467 io.Copy(&snapshot, ringBuffer) 1468 err = &smithy.DeserializationError{ 1469 Err: fmt.Errorf("failed to decode response body, %w", err), 1470 Snapshot: snapshot.Bytes(), 1471 } 1472 return out, metadata, err 1473 } 1474 1475 return out, metadata, err 1476} 1477 1478func awsEc2query_deserializeOpErrorXmlLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1479 var errorBuffer bytes.Buffer 1480 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1481 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1482 } 1483 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1484 1485 errorCode := "UnknownError" 1486 errorMessage := errorCode 1487 1488 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1489 if err != nil { 1490 return err 1491 } 1492 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1493 if len(errorComponents.Code) != 0 { 1494 errorCode = errorComponents.Code 1495 } 1496 if len(errorComponents.Message) != 0 { 1497 errorMessage = errorComponents.Message 1498 } 1499 errorBody.Seek(0, io.SeekStart) 1500 switch { 1501 default: 1502 genericError := &smithy.GenericAPIError{ 1503 Code: errorCode, 1504 Message: errorMessage, 1505 } 1506 return genericError 1507 1508 } 1509} 1510 1511type awsEc2query_deserializeOpXmlNamespaces struct { 1512} 1513 1514func (*awsEc2query_deserializeOpXmlNamespaces) ID() string { 1515 return "OperationDeserializer" 1516} 1517 1518func (m *awsEc2query_deserializeOpXmlNamespaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1519 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1520) { 1521 out, metadata, err = next.HandleDeserialize(ctx, in) 1522 if err != nil { 1523 return out, metadata, err 1524 } 1525 1526 response, ok := out.RawResponse.(*smithyhttp.Response) 1527 if !ok { 1528 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1529 } 1530 1531 if response.StatusCode < 200 || response.StatusCode >= 300 { 1532 return out, metadata, awsEc2query_deserializeOpErrorXmlNamespaces(response, &metadata) 1533 } 1534 output := &XmlNamespacesOutput{} 1535 out.Result = output 1536 1537 var buff [1024]byte 1538 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1539 body := io.TeeReader(response.Body, ringBuffer) 1540 rootDecoder := xml.NewDecoder(body) 1541 t, err := smithyxml.FetchRootElement(rootDecoder) 1542 if err == io.EOF { 1543 return out, metadata, nil 1544 } 1545 if err != nil { 1546 var snapshot bytes.Buffer 1547 io.Copy(&snapshot, ringBuffer) 1548 return out, metadata, &smithy.DeserializationError{ 1549 Err: fmt.Errorf("failed to decode response body, %w", err), 1550 Snapshot: snapshot.Bytes(), 1551 } 1552 } 1553 1554 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1555 err = awsEc2query_deserializeOpDocumentXmlNamespacesOutput(&output, decoder) 1556 if err != nil { 1557 var snapshot bytes.Buffer 1558 io.Copy(&snapshot, ringBuffer) 1559 err = &smithy.DeserializationError{ 1560 Err: fmt.Errorf("failed to decode response body, %w", err), 1561 Snapshot: snapshot.Bytes(), 1562 } 1563 return out, metadata, err 1564 } 1565 1566 return out, metadata, err 1567} 1568 1569func awsEc2query_deserializeOpErrorXmlNamespaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1570 var errorBuffer bytes.Buffer 1571 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1572 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1573 } 1574 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1575 1576 errorCode := "UnknownError" 1577 errorMessage := errorCode 1578 1579 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1580 if err != nil { 1581 return err 1582 } 1583 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1584 if len(errorComponents.Code) != 0 { 1585 errorCode = errorComponents.Code 1586 } 1587 if len(errorComponents.Message) != 0 { 1588 errorMessage = errorComponents.Message 1589 } 1590 errorBody.Seek(0, io.SeekStart) 1591 switch { 1592 default: 1593 genericError := &smithy.GenericAPIError{ 1594 Code: errorCode, 1595 Message: errorMessage, 1596 } 1597 return genericError 1598 1599 } 1600} 1601 1602type awsEc2query_deserializeOpXmlTimestamps struct { 1603} 1604 1605func (*awsEc2query_deserializeOpXmlTimestamps) ID() string { 1606 return "OperationDeserializer" 1607} 1608 1609func (m *awsEc2query_deserializeOpXmlTimestamps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1610 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1611) { 1612 out, metadata, err = next.HandleDeserialize(ctx, in) 1613 if err != nil { 1614 return out, metadata, err 1615 } 1616 1617 response, ok := out.RawResponse.(*smithyhttp.Response) 1618 if !ok { 1619 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1620 } 1621 1622 if response.StatusCode < 200 || response.StatusCode >= 300 { 1623 return out, metadata, awsEc2query_deserializeOpErrorXmlTimestamps(response, &metadata) 1624 } 1625 output := &XmlTimestampsOutput{} 1626 out.Result = output 1627 1628 var buff [1024]byte 1629 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1630 body := io.TeeReader(response.Body, ringBuffer) 1631 rootDecoder := xml.NewDecoder(body) 1632 t, err := smithyxml.FetchRootElement(rootDecoder) 1633 if err == io.EOF { 1634 return out, metadata, nil 1635 } 1636 if err != nil { 1637 var snapshot bytes.Buffer 1638 io.Copy(&snapshot, ringBuffer) 1639 return out, metadata, &smithy.DeserializationError{ 1640 Err: fmt.Errorf("failed to decode response body, %w", err), 1641 Snapshot: snapshot.Bytes(), 1642 } 1643 } 1644 1645 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1646 err = awsEc2query_deserializeOpDocumentXmlTimestampsOutput(&output, decoder) 1647 if err != nil { 1648 var snapshot bytes.Buffer 1649 io.Copy(&snapshot, ringBuffer) 1650 err = &smithy.DeserializationError{ 1651 Err: fmt.Errorf("failed to decode response body, %w", err), 1652 Snapshot: snapshot.Bytes(), 1653 } 1654 return out, metadata, err 1655 } 1656 1657 return out, metadata, err 1658} 1659 1660func awsEc2query_deserializeOpErrorXmlTimestamps(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1661 var errorBuffer bytes.Buffer 1662 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1663 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1664 } 1665 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1666 1667 errorCode := "UnknownError" 1668 errorMessage := errorCode 1669 1670 errorComponents, err := ec2query.GetErrorResponseComponents(errorBody) 1671 if err != nil { 1672 return err 1673 } 1674 awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID) 1675 if len(errorComponents.Code) != 0 { 1676 errorCode = errorComponents.Code 1677 } 1678 if len(errorComponents.Message) != 0 { 1679 errorMessage = errorComponents.Message 1680 } 1681 errorBody.Seek(0, io.SeekStart) 1682 switch { 1683 default: 1684 genericError := &smithy.GenericAPIError{ 1685 Code: errorCode, 1686 Message: errorMessage, 1687 } 1688 return genericError 1689 1690 } 1691} 1692 1693func awsEc2query_deserializeErrorComplexError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1694 output := &types.ComplexError{} 1695 var buff [1024]byte 1696 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1697 body := io.TeeReader(errorBody, ringBuffer) 1698 rootDecoder := xml.NewDecoder(body) 1699 t, err := smithyxml.FetchRootElement(rootDecoder) 1700 if err == io.EOF { 1701 return output 1702 } 1703 if err != nil { 1704 var snapshot bytes.Buffer 1705 io.Copy(&snapshot, ringBuffer) 1706 return &smithy.DeserializationError{ 1707 Err: fmt.Errorf("failed to decode response body, %w", err), 1708 Snapshot: snapshot.Bytes(), 1709 } 1710 } 1711 1712 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1713 t, err = decoder.GetElement("Errors") 1714 if err != nil { 1715 var snapshot bytes.Buffer 1716 io.Copy(&snapshot, ringBuffer) 1717 return &smithy.DeserializationError{ 1718 Err: fmt.Errorf("failed to decode response body, %w", err), 1719 Snapshot: snapshot.Bytes(), 1720 } 1721 } 1722 1723 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1724 t, err = decoder.GetElement("Error") 1725 if err != nil { 1726 var snapshot bytes.Buffer 1727 io.Copy(&snapshot, ringBuffer) 1728 return &smithy.DeserializationError{ 1729 Err: fmt.Errorf("failed to decode response body, %w", err), 1730 Snapshot: snapshot.Bytes(), 1731 } 1732 } 1733 1734 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1735 err = awsEc2query_deserializeDocumentComplexError(&output, decoder) 1736 if err != nil { 1737 var snapshot bytes.Buffer 1738 io.Copy(&snapshot, ringBuffer) 1739 return &smithy.DeserializationError{ 1740 Err: fmt.Errorf("failed to decode response body, %w", err), 1741 Snapshot: snapshot.Bytes(), 1742 } 1743 } 1744 1745 return output 1746} 1747 1748func awsEc2query_deserializeErrorInvalidGreeting(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1749 output := &types.InvalidGreeting{} 1750 var buff [1024]byte 1751 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1752 body := io.TeeReader(errorBody, ringBuffer) 1753 rootDecoder := xml.NewDecoder(body) 1754 t, err := smithyxml.FetchRootElement(rootDecoder) 1755 if err == io.EOF { 1756 return output 1757 } 1758 if err != nil { 1759 var snapshot bytes.Buffer 1760 io.Copy(&snapshot, ringBuffer) 1761 return &smithy.DeserializationError{ 1762 Err: fmt.Errorf("failed to decode response body, %w", err), 1763 Snapshot: snapshot.Bytes(), 1764 } 1765 } 1766 1767 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1768 t, err = decoder.GetElement("Errors") 1769 if err != nil { 1770 var snapshot bytes.Buffer 1771 io.Copy(&snapshot, ringBuffer) 1772 return &smithy.DeserializationError{ 1773 Err: fmt.Errorf("failed to decode response body, %w", err), 1774 Snapshot: snapshot.Bytes(), 1775 } 1776 } 1777 1778 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1779 t, err = decoder.GetElement("Error") 1780 if err != nil { 1781 var snapshot bytes.Buffer 1782 io.Copy(&snapshot, ringBuffer) 1783 return &smithy.DeserializationError{ 1784 Err: fmt.Errorf("failed to decode response body, %w", err), 1785 Snapshot: snapshot.Bytes(), 1786 } 1787 } 1788 1789 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1790 err = awsEc2query_deserializeDocumentInvalidGreeting(&output, decoder) 1791 if err != nil { 1792 var snapshot bytes.Buffer 1793 io.Copy(&snapshot, ringBuffer) 1794 return &smithy.DeserializationError{ 1795 Err: fmt.Errorf("failed to decode response body, %w", err), 1796 Snapshot: snapshot.Bytes(), 1797 } 1798 } 1799 1800 return output 1801} 1802 1803func awsEc2query_deserializeDocumentComplexError(v **types.ComplexError, decoder smithyxml.NodeDecoder) error { 1804 if v == nil { 1805 return fmt.Errorf("unexpected nil of type %T", v) 1806 } 1807 var sv *types.ComplexError 1808 if *v == nil { 1809 sv = &types.ComplexError{} 1810 } else { 1811 sv = *v 1812 } 1813 1814 for { 1815 t, done, err := decoder.Token() 1816 if err != nil { 1817 return err 1818 } 1819 if done { 1820 break 1821 } 1822 originalDecoder := decoder 1823 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1824 switch { 1825 case strings.EqualFold("Nested", t.Name.Local): 1826 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1827 if err := awsEc2query_deserializeDocumentComplexNestedErrorData(&sv.Nested, nodeDecoder); err != nil { 1828 return err 1829 } 1830 1831 case strings.EqualFold("TopLevel", t.Name.Local): 1832 val, err := decoder.Value() 1833 if err != nil { 1834 return err 1835 } 1836 if val == nil { 1837 break 1838 } 1839 { 1840 xtv := string(val) 1841 sv.TopLevel = ptr.String(xtv) 1842 } 1843 1844 default: 1845 // Do nothing and ignore the unexpected tag element 1846 err = decoder.Decoder.Skip() 1847 if err != nil { 1848 return err 1849 } 1850 1851 } 1852 decoder = originalDecoder 1853 } 1854 *v = sv 1855 return nil 1856} 1857 1858func awsEc2query_deserializeDocumentComplexNestedErrorData(v **types.ComplexNestedErrorData, decoder smithyxml.NodeDecoder) error { 1859 if v == nil { 1860 return fmt.Errorf("unexpected nil of type %T", v) 1861 } 1862 var sv *types.ComplexNestedErrorData 1863 if *v == nil { 1864 sv = &types.ComplexNestedErrorData{} 1865 } else { 1866 sv = *v 1867 } 1868 1869 for { 1870 t, done, err := decoder.Token() 1871 if err != nil { 1872 return err 1873 } 1874 if done { 1875 break 1876 } 1877 originalDecoder := decoder 1878 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1879 switch { 1880 case strings.EqualFold("Foo", t.Name.Local): 1881 val, err := decoder.Value() 1882 if err != nil { 1883 return err 1884 } 1885 if val == nil { 1886 break 1887 } 1888 { 1889 xtv := string(val) 1890 sv.Foo = ptr.String(xtv) 1891 } 1892 1893 default: 1894 // Do nothing and ignore the unexpected tag element 1895 err = decoder.Decoder.Skip() 1896 if err != nil { 1897 return err 1898 } 1899 1900 } 1901 decoder = originalDecoder 1902 } 1903 *v = sv 1904 return nil 1905} 1906 1907func awsEc2query_deserializeDocumentInvalidGreeting(v **types.InvalidGreeting, decoder smithyxml.NodeDecoder) error { 1908 if v == nil { 1909 return fmt.Errorf("unexpected nil of type %T", v) 1910 } 1911 var sv *types.InvalidGreeting 1912 if *v == nil { 1913 sv = &types.InvalidGreeting{} 1914 } else { 1915 sv = *v 1916 } 1917 1918 for { 1919 t, done, err := decoder.Token() 1920 if err != nil { 1921 return err 1922 } 1923 if done { 1924 break 1925 } 1926 originalDecoder := decoder 1927 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1928 switch { 1929 case strings.EqualFold("Message", t.Name.Local): 1930 val, err := decoder.Value() 1931 if err != nil { 1932 return err 1933 } 1934 if val == nil { 1935 break 1936 } 1937 { 1938 xtv := string(val) 1939 sv.Message = ptr.String(xtv) 1940 } 1941 1942 default: 1943 // Do nothing and ignore the unexpected tag element 1944 err = decoder.Decoder.Skip() 1945 if err != nil { 1946 return err 1947 } 1948 1949 } 1950 decoder = originalDecoder 1951 } 1952 *v = sv 1953 return nil 1954} 1955 1956func awsEc2query_deserializeDocumentListWithMemberNamespace(v *[]string, decoder smithyxml.NodeDecoder) error { 1957 if v == nil { 1958 return fmt.Errorf("unexpected nil of type %T", v) 1959 } 1960 var sv []string 1961 if *v == nil { 1962 sv = make([]string, 0) 1963 } else { 1964 sv = *v 1965 } 1966 1967 originalDecoder := decoder 1968 for { 1969 t, done, err := decoder.Token() 1970 if err != nil { 1971 return err 1972 } 1973 if done { 1974 break 1975 } 1976 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1977 decoder = memberDecoder 1978 switch { 1979 case strings.EqualFold("member", t.Name.Local): 1980 var col string 1981 val, err := decoder.Value() 1982 if err != nil { 1983 return err 1984 } 1985 if val == nil { 1986 break 1987 } 1988 { 1989 xtv := string(val) 1990 col = xtv 1991 } 1992 sv = append(sv, col) 1993 1994 default: 1995 err = decoder.Decoder.Skip() 1996 if err != nil { 1997 return err 1998 } 1999 2000 } 2001 decoder = originalDecoder 2002 } 2003 *v = sv 2004 return nil 2005} 2006 2007func awsEc2query_deserializeDocumentListWithMemberNamespaceUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 2008 var sv []string 2009 if *v == nil { 2010 sv = make([]string, 0) 2011 } else { 2012 sv = *v 2013 } 2014 2015 switch { 2016 default: 2017 var mv string 2018 t := decoder.StartEl 2019 _ = t 2020 val, err := decoder.Value() 2021 if err != nil { 2022 return err 2023 } 2024 if val == nil { 2025 break 2026 } 2027 { 2028 xtv := string(val) 2029 mv = xtv 2030 } 2031 sv = append(sv, mv) 2032 } 2033 *v = sv 2034 return nil 2035} 2036func awsEc2query_deserializeDocumentListWithNamespace(v *[]string, decoder smithyxml.NodeDecoder) error { 2037 if v == nil { 2038 return fmt.Errorf("unexpected nil of type %T", v) 2039 } 2040 var sv []string 2041 if *v == nil { 2042 sv = make([]string, 0) 2043 } else { 2044 sv = *v 2045 } 2046 2047 originalDecoder := decoder 2048 for { 2049 t, done, err := decoder.Token() 2050 if err != nil { 2051 return err 2052 } 2053 if done { 2054 break 2055 } 2056 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2057 decoder = memberDecoder 2058 switch { 2059 case strings.EqualFold("member", t.Name.Local): 2060 var col string 2061 val, err := decoder.Value() 2062 if err != nil { 2063 return err 2064 } 2065 if val == nil { 2066 break 2067 } 2068 { 2069 xtv := string(val) 2070 col = xtv 2071 } 2072 sv = append(sv, col) 2073 2074 default: 2075 err = decoder.Decoder.Skip() 2076 if err != nil { 2077 return err 2078 } 2079 2080 } 2081 decoder = originalDecoder 2082 } 2083 *v = sv 2084 return nil 2085} 2086 2087func awsEc2query_deserializeDocumentListWithNamespaceUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 2088 var sv []string 2089 if *v == nil { 2090 sv = make([]string, 0) 2091 } else { 2092 sv = *v 2093 } 2094 2095 switch { 2096 default: 2097 var mv string 2098 t := decoder.StartEl 2099 _ = t 2100 val, err := decoder.Value() 2101 if err != nil { 2102 return err 2103 } 2104 if val == nil { 2105 break 2106 } 2107 { 2108 xtv := string(val) 2109 mv = xtv 2110 } 2111 sv = append(sv, mv) 2112 } 2113 *v = sv 2114 return nil 2115} 2116func awsEc2query_deserializeDocumentRecursiveXmlShapesOutputNested1(v **types.RecursiveXmlShapesOutputNested1, decoder smithyxml.NodeDecoder) error { 2117 if v == nil { 2118 return fmt.Errorf("unexpected nil of type %T", v) 2119 } 2120 var sv *types.RecursiveXmlShapesOutputNested1 2121 if *v == nil { 2122 sv = &types.RecursiveXmlShapesOutputNested1{} 2123 } else { 2124 sv = *v 2125 } 2126 2127 for { 2128 t, done, err := decoder.Token() 2129 if err != nil { 2130 return err 2131 } 2132 if done { 2133 break 2134 } 2135 originalDecoder := decoder 2136 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2137 switch { 2138 case strings.EqualFold("foo", t.Name.Local): 2139 val, err := decoder.Value() 2140 if err != nil { 2141 return err 2142 } 2143 if val == nil { 2144 break 2145 } 2146 { 2147 xtv := string(val) 2148 sv.Foo = ptr.String(xtv) 2149 } 2150 2151 case strings.EqualFold("nested", t.Name.Local): 2152 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2153 if err := awsEc2query_deserializeDocumentRecursiveXmlShapesOutputNested2(&sv.Nested, nodeDecoder); err != nil { 2154 return err 2155 } 2156 2157 default: 2158 // Do nothing and ignore the unexpected tag element 2159 err = decoder.Decoder.Skip() 2160 if err != nil { 2161 return err 2162 } 2163 2164 } 2165 decoder = originalDecoder 2166 } 2167 *v = sv 2168 return nil 2169} 2170 2171func awsEc2query_deserializeDocumentRecursiveXmlShapesOutputNested2(v **types.RecursiveXmlShapesOutputNested2, decoder smithyxml.NodeDecoder) error { 2172 if v == nil { 2173 return fmt.Errorf("unexpected nil of type %T", v) 2174 } 2175 var sv *types.RecursiveXmlShapesOutputNested2 2176 if *v == nil { 2177 sv = &types.RecursiveXmlShapesOutputNested2{} 2178 } else { 2179 sv = *v 2180 } 2181 2182 for { 2183 t, done, err := decoder.Token() 2184 if err != nil { 2185 return err 2186 } 2187 if done { 2188 break 2189 } 2190 originalDecoder := decoder 2191 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2192 switch { 2193 case strings.EqualFold("bar", t.Name.Local): 2194 val, err := decoder.Value() 2195 if err != nil { 2196 return err 2197 } 2198 if val == nil { 2199 break 2200 } 2201 { 2202 xtv := string(val) 2203 sv.Bar = ptr.String(xtv) 2204 } 2205 2206 case strings.EqualFold("recursiveMember", t.Name.Local): 2207 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2208 if err := awsEc2query_deserializeDocumentRecursiveXmlShapesOutputNested1(&sv.RecursiveMember, nodeDecoder); err != nil { 2209 return err 2210 } 2211 2212 default: 2213 // Do nothing and ignore the unexpected tag element 2214 err = decoder.Decoder.Skip() 2215 if err != nil { 2216 return err 2217 } 2218 2219 } 2220 decoder = originalDecoder 2221 } 2222 *v = sv 2223 return nil 2224} 2225 2226func awsEc2query_deserializeDocumentRenamedListMembers(v *[]string, decoder smithyxml.NodeDecoder) error { 2227 if v == nil { 2228 return fmt.Errorf("unexpected nil of type %T", v) 2229 } 2230 var sv []string 2231 if *v == nil { 2232 sv = make([]string, 0) 2233 } else { 2234 sv = *v 2235 } 2236 2237 originalDecoder := decoder 2238 for { 2239 t, done, err := decoder.Token() 2240 if err != nil { 2241 return err 2242 } 2243 if done { 2244 break 2245 } 2246 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2247 decoder = memberDecoder 2248 switch { 2249 case strings.EqualFold("item", t.Name.Local): 2250 var col string 2251 val, err := decoder.Value() 2252 if err != nil { 2253 return err 2254 } 2255 if val == nil { 2256 break 2257 } 2258 { 2259 xtv := string(val) 2260 col = xtv 2261 } 2262 sv = append(sv, col) 2263 2264 default: 2265 err = decoder.Decoder.Skip() 2266 if err != nil { 2267 return err 2268 } 2269 2270 } 2271 decoder = originalDecoder 2272 } 2273 *v = sv 2274 return nil 2275} 2276 2277func awsEc2query_deserializeDocumentRenamedListMembersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 2278 var sv []string 2279 if *v == nil { 2280 sv = make([]string, 0) 2281 } else { 2282 sv = *v 2283 } 2284 2285 switch { 2286 default: 2287 var mv string 2288 t := decoder.StartEl 2289 _ = t 2290 val, err := decoder.Value() 2291 if err != nil { 2292 return err 2293 } 2294 if val == nil { 2295 break 2296 } 2297 { 2298 xtv := string(val) 2299 mv = xtv 2300 } 2301 sv = append(sv, mv) 2302 } 2303 *v = sv 2304 return nil 2305} 2306func awsEc2query_deserializeDocumentStructureList(v *[]types.StructureListMember, decoder smithyxml.NodeDecoder) error { 2307 if v == nil { 2308 return fmt.Errorf("unexpected nil of type %T", v) 2309 } 2310 var sv []types.StructureListMember 2311 if *v == nil { 2312 sv = make([]types.StructureListMember, 0) 2313 } else { 2314 sv = *v 2315 } 2316 2317 originalDecoder := decoder 2318 for { 2319 t, done, err := decoder.Token() 2320 if err != nil { 2321 return err 2322 } 2323 if done { 2324 break 2325 } 2326 switch { 2327 case strings.EqualFold("item", t.Name.Local): 2328 var col types.StructureListMember 2329 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2330 destAddr := &col 2331 if err := awsEc2query_deserializeDocumentStructureListMember(&destAddr, nodeDecoder); err != nil { 2332 return err 2333 } 2334 col = *destAddr 2335 sv = append(sv, col) 2336 2337 default: 2338 err = decoder.Decoder.Skip() 2339 if err != nil { 2340 return err 2341 } 2342 2343 } 2344 decoder = originalDecoder 2345 } 2346 *v = sv 2347 return nil 2348} 2349 2350func awsEc2query_deserializeDocumentStructureListUnwrapped(v *[]types.StructureListMember, decoder smithyxml.NodeDecoder) error { 2351 var sv []types.StructureListMember 2352 if *v == nil { 2353 sv = make([]types.StructureListMember, 0) 2354 } else { 2355 sv = *v 2356 } 2357 2358 switch { 2359 default: 2360 var mv types.StructureListMember 2361 t := decoder.StartEl 2362 _ = t 2363 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2364 destAddr := &mv 2365 if err := awsEc2query_deserializeDocumentStructureListMember(&destAddr, nodeDecoder); err != nil { 2366 return err 2367 } 2368 mv = *destAddr 2369 sv = append(sv, mv) 2370 } 2371 *v = sv 2372 return nil 2373} 2374func awsEc2query_deserializeDocumentStructureListMember(v **types.StructureListMember, decoder smithyxml.NodeDecoder) error { 2375 if v == nil { 2376 return fmt.Errorf("unexpected nil of type %T", v) 2377 } 2378 var sv *types.StructureListMember 2379 if *v == nil { 2380 sv = &types.StructureListMember{} 2381 } else { 2382 sv = *v 2383 } 2384 2385 for { 2386 t, done, err := decoder.Token() 2387 if err != nil { 2388 return err 2389 } 2390 if done { 2391 break 2392 } 2393 originalDecoder := decoder 2394 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2395 switch { 2396 case strings.EqualFold("value", t.Name.Local): 2397 val, err := decoder.Value() 2398 if err != nil { 2399 return err 2400 } 2401 if val == nil { 2402 break 2403 } 2404 { 2405 xtv := string(val) 2406 sv.A = ptr.String(xtv) 2407 } 2408 2409 case strings.EqualFold("other", t.Name.Local): 2410 val, err := decoder.Value() 2411 if err != nil { 2412 return err 2413 } 2414 if val == nil { 2415 break 2416 } 2417 { 2418 xtv := string(val) 2419 sv.B = ptr.String(xtv) 2420 } 2421 2422 default: 2423 // Do nothing and ignore the unexpected tag element 2424 err = decoder.Decoder.Skip() 2425 if err != nil { 2426 return err 2427 } 2428 2429 } 2430 decoder = originalDecoder 2431 } 2432 *v = sv 2433 return nil 2434} 2435 2436func awsEc2query_deserializeDocumentXmlNamespacedList(v *[]string, decoder smithyxml.NodeDecoder) error { 2437 if v == nil { 2438 return fmt.Errorf("unexpected nil of type %T", v) 2439 } 2440 var sv []string 2441 if *v == nil { 2442 sv = make([]string, 0) 2443 } else { 2444 sv = *v 2445 } 2446 2447 originalDecoder := decoder 2448 for { 2449 t, done, err := decoder.Token() 2450 if err != nil { 2451 return err 2452 } 2453 if done { 2454 break 2455 } 2456 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2457 decoder = memberDecoder 2458 switch { 2459 case strings.EqualFold("member", t.Name.Local): 2460 var col string 2461 val, err := decoder.Value() 2462 if err != nil { 2463 return err 2464 } 2465 if val == nil { 2466 break 2467 } 2468 { 2469 xtv := string(val) 2470 col = xtv 2471 } 2472 sv = append(sv, col) 2473 2474 default: 2475 err = decoder.Decoder.Skip() 2476 if err != nil { 2477 return err 2478 } 2479 2480 } 2481 decoder = originalDecoder 2482 } 2483 *v = sv 2484 return nil 2485} 2486 2487func awsEc2query_deserializeDocumentXmlNamespacedListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 2488 var sv []string 2489 if *v == nil { 2490 sv = make([]string, 0) 2491 } else { 2492 sv = *v 2493 } 2494 2495 switch { 2496 default: 2497 var mv string 2498 t := decoder.StartEl 2499 _ = t 2500 val, err := decoder.Value() 2501 if err != nil { 2502 return err 2503 } 2504 if val == nil { 2505 break 2506 } 2507 { 2508 xtv := string(val) 2509 mv = xtv 2510 } 2511 sv = append(sv, mv) 2512 } 2513 *v = sv 2514 return nil 2515} 2516func awsEc2query_deserializeDocumentXmlNamespaceNested(v **types.XmlNamespaceNested, decoder smithyxml.NodeDecoder) error { 2517 if v == nil { 2518 return fmt.Errorf("unexpected nil of type %T", v) 2519 } 2520 var sv *types.XmlNamespaceNested 2521 if *v == nil { 2522 sv = &types.XmlNamespaceNested{} 2523 } else { 2524 sv = *v 2525 } 2526 2527 for { 2528 t, done, err := decoder.Token() 2529 if err != nil { 2530 return err 2531 } 2532 if done { 2533 break 2534 } 2535 originalDecoder := decoder 2536 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2537 switch { 2538 case strings.EqualFold("foo", t.Name.Local): 2539 val, err := decoder.Value() 2540 if err != nil { 2541 return err 2542 } 2543 if val == nil { 2544 break 2545 } 2546 { 2547 xtv := string(val) 2548 sv.Foo = ptr.String(xtv) 2549 } 2550 2551 case strings.EqualFold("values", t.Name.Local): 2552 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2553 if err := awsEc2query_deserializeDocumentXmlNamespacedList(&sv.Values, nodeDecoder); err != nil { 2554 return err 2555 } 2556 2557 default: 2558 // Do nothing and ignore the unexpected tag element 2559 err = decoder.Decoder.Skip() 2560 if err != nil { 2561 return err 2562 } 2563 2564 } 2565 decoder = originalDecoder 2566 } 2567 *v = sv 2568 return nil 2569} 2570 2571func awsEc2query_deserializeDocumentBooleanList(v *[]bool, decoder smithyxml.NodeDecoder) error { 2572 if v == nil { 2573 return fmt.Errorf("unexpected nil of type %T", v) 2574 } 2575 var sv []bool 2576 if *v == nil { 2577 sv = make([]bool, 0) 2578 } else { 2579 sv = *v 2580 } 2581 2582 originalDecoder := decoder 2583 for { 2584 t, done, err := decoder.Token() 2585 if err != nil { 2586 return err 2587 } 2588 if done { 2589 break 2590 } 2591 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2592 decoder = memberDecoder 2593 switch { 2594 case strings.EqualFold("member", t.Name.Local): 2595 var col bool 2596 val, err := decoder.Value() 2597 if err != nil { 2598 return err 2599 } 2600 if val == nil { 2601 break 2602 } 2603 { 2604 xtv, err := strconv.ParseBool(string(val)) 2605 if err != nil { 2606 return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", val) 2607 } 2608 col = xtv 2609 } 2610 sv = append(sv, col) 2611 2612 default: 2613 err = decoder.Decoder.Skip() 2614 if err != nil { 2615 return err 2616 } 2617 2618 } 2619 decoder = originalDecoder 2620 } 2621 *v = sv 2622 return nil 2623} 2624 2625func awsEc2query_deserializeDocumentBooleanListUnwrapped(v *[]bool, decoder smithyxml.NodeDecoder) error { 2626 var sv []bool 2627 if *v == nil { 2628 sv = make([]bool, 0) 2629 } else { 2630 sv = *v 2631 } 2632 2633 switch { 2634 default: 2635 var mv bool 2636 t := decoder.StartEl 2637 _ = t 2638 val, err := decoder.Value() 2639 if err != nil { 2640 return err 2641 } 2642 if val == nil { 2643 break 2644 } 2645 { 2646 xtv, err := strconv.ParseBool(string(val)) 2647 if err != nil { 2648 return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", val) 2649 } 2650 mv = xtv 2651 } 2652 sv = append(sv, mv) 2653 } 2654 *v = sv 2655 return nil 2656} 2657func awsEc2query_deserializeDocumentFooEnumList(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 2658 if v == nil { 2659 return fmt.Errorf("unexpected nil of type %T", v) 2660 } 2661 var sv []types.FooEnum 2662 if *v == nil { 2663 sv = make([]types.FooEnum, 0) 2664 } else { 2665 sv = *v 2666 } 2667 2668 originalDecoder := decoder 2669 for { 2670 t, done, err := decoder.Token() 2671 if err != nil { 2672 return err 2673 } 2674 if done { 2675 break 2676 } 2677 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2678 decoder = memberDecoder 2679 switch { 2680 case strings.EqualFold("member", t.Name.Local): 2681 var col types.FooEnum 2682 val, err := decoder.Value() 2683 if err != nil { 2684 return err 2685 } 2686 if val == nil { 2687 break 2688 } 2689 { 2690 xtv := string(val) 2691 col = types.FooEnum(xtv) 2692 } 2693 sv = append(sv, col) 2694 2695 default: 2696 err = decoder.Decoder.Skip() 2697 if err != nil { 2698 return err 2699 } 2700 2701 } 2702 decoder = originalDecoder 2703 } 2704 *v = sv 2705 return nil 2706} 2707 2708func awsEc2query_deserializeDocumentFooEnumListUnwrapped(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 2709 var sv []types.FooEnum 2710 if *v == nil { 2711 sv = make([]types.FooEnum, 0) 2712 } else { 2713 sv = *v 2714 } 2715 2716 switch { 2717 default: 2718 var mv types.FooEnum 2719 t := decoder.StartEl 2720 _ = t 2721 val, err := decoder.Value() 2722 if err != nil { 2723 return err 2724 } 2725 if val == nil { 2726 break 2727 } 2728 { 2729 xtv := string(val) 2730 mv = types.FooEnum(xtv) 2731 } 2732 sv = append(sv, mv) 2733 } 2734 *v = sv 2735 return nil 2736} 2737func awsEc2query_deserializeDocumentFooEnumMap(v *map[string]types.FooEnum, decoder smithyxml.NodeDecoder) error { 2738 if v == nil { 2739 return fmt.Errorf("unexpected nil of type %T", v) 2740 } 2741 var sv map[string]types.FooEnum 2742 if *v == nil { 2743 sv = make(map[string]types.FooEnum, 0) 2744 } else { 2745 sv = *v 2746 } 2747 2748 for { 2749 t, done, err := decoder.Token() 2750 if err != nil { 2751 return err 2752 } 2753 if done { 2754 break 2755 } 2756 switch { 2757 case strings.EqualFold("entry", t.Name.Local): 2758 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2759 if err := awsEc2query_deserializeDocumentFooEnumMapUnwrapped(&sv, entryDecoder); err != nil { 2760 return err 2761 } 2762 2763 default: 2764 err = decoder.Decoder.Skip() 2765 if err != nil { 2766 return err 2767 } 2768 2769 } 2770 } 2771 *v = sv 2772 return nil 2773} 2774 2775func awsEc2query_deserializeDocumentFooEnumMapUnwrapped(v *map[string]types.FooEnum, decoder smithyxml.NodeDecoder) error { 2776 var sv map[string]types.FooEnum 2777 if *v == nil { 2778 sv = make(map[string]types.FooEnum, 0) 2779 } else { 2780 sv = *v 2781 } 2782 2783 var ek string 2784 var ev types.FooEnum 2785 for { 2786 t, done, err := decoder.Token() 2787 if err != nil { 2788 return err 2789 } 2790 if done { 2791 sv[ek] = ev 2792 break 2793 } 2794 originalDecoder := decoder 2795 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2796 switch { 2797 case strings.EqualFold("key", t.Name.Local): 2798 val, err := decoder.Value() 2799 if err != nil { 2800 return err 2801 } 2802 if val == nil { 2803 break 2804 } 2805 { 2806 xtv := string(val) 2807 ek = xtv 2808 } 2809 2810 case strings.EqualFold("value", t.Name.Local): 2811 val, err := decoder.Value() 2812 if err != nil { 2813 return err 2814 } 2815 if val == nil { 2816 break 2817 } 2818 { 2819 xtv := string(val) 2820 ev = types.FooEnum(xtv) 2821 } 2822 2823 default: 2824 err = decoder.Decoder.Skip() 2825 if err != nil { 2826 return err 2827 } 2828 2829 } 2830 decoder = originalDecoder 2831 } 2832 *v = sv 2833 return nil 2834} 2835func awsEc2query_deserializeDocumentFooEnumSet(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 2836 if v == nil { 2837 return fmt.Errorf("unexpected nil of type %T", v) 2838 } 2839 var sv []types.FooEnum 2840 if *v == nil { 2841 sv = make([]types.FooEnum, 0) 2842 } else { 2843 sv = *v 2844 } 2845 2846 originalDecoder := decoder 2847 for { 2848 t, done, err := decoder.Token() 2849 if err != nil { 2850 return err 2851 } 2852 if done { 2853 break 2854 } 2855 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2856 decoder = memberDecoder 2857 switch { 2858 case strings.EqualFold("member", t.Name.Local): 2859 var col types.FooEnum 2860 val, err := decoder.Value() 2861 if err != nil { 2862 return err 2863 } 2864 if val == nil { 2865 break 2866 } 2867 { 2868 xtv := string(val) 2869 col = types.FooEnum(xtv) 2870 } 2871 sv = append(sv, col) 2872 2873 default: 2874 err = decoder.Decoder.Skip() 2875 if err != nil { 2876 return err 2877 } 2878 2879 } 2880 decoder = originalDecoder 2881 } 2882 *v = sv 2883 return nil 2884} 2885 2886func awsEc2query_deserializeDocumentFooEnumSetUnwrapped(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 2887 var sv []types.FooEnum 2888 if *v == nil { 2889 sv = make([]types.FooEnum, 0) 2890 } else { 2891 sv = *v 2892 } 2893 2894 switch { 2895 default: 2896 var mv types.FooEnum 2897 t := decoder.StartEl 2898 _ = t 2899 val, err := decoder.Value() 2900 if err != nil { 2901 return err 2902 } 2903 if val == nil { 2904 break 2905 } 2906 { 2907 xtv := string(val) 2908 mv = types.FooEnum(xtv) 2909 } 2910 sv = append(sv, mv) 2911 } 2912 *v = sv 2913 return nil 2914} 2915func awsEc2query_deserializeDocumentIntegerList(v *[]int32, decoder smithyxml.NodeDecoder) error { 2916 if v == nil { 2917 return fmt.Errorf("unexpected nil of type %T", v) 2918 } 2919 var sv []int32 2920 if *v == nil { 2921 sv = make([]int32, 0) 2922 } else { 2923 sv = *v 2924 } 2925 2926 originalDecoder := decoder 2927 for { 2928 t, done, err := decoder.Token() 2929 if err != nil { 2930 return err 2931 } 2932 if done { 2933 break 2934 } 2935 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2936 decoder = memberDecoder 2937 switch { 2938 case strings.EqualFold("member", t.Name.Local): 2939 var col int32 2940 val, err := decoder.Value() 2941 if err != nil { 2942 return err 2943 } 2944 if val == nil { 2945 break 2946 } 2947 { 2948 xtv := string(val) 2949 i64, err := strconv.ParseInt(xtv, 10, 64) 2950 if err != nil { 2951 return err 2952 } 2953 col = int32(i64) 2954 } 2955 sv = append(sv, col) 2956 2957 default: 2958 err = decoder.Decoder.Skip() 2959 if err != nil { 2960 return err 2961 } 2962 2963 } 2964 decoder = originalDecoder 2965 } 2966 *v = sv 2967 return nil 2968} 2969 2970func awsEc2query_deserializeDocumentIntegerListUnwrapped(v *[]int32, decoder smithyxml.NodeDecoder) error { 2971 var sv []int32 2972 if *v == nil { 2973 sv = make([]int32, 0) 2974 } else { 2975 sv = *v 2976 } 2977 2978 switch { 2979 default: 2980 var mv int32 2981 t := decoder.StartEl 2982 _ = t 2983 val, err := decoder.Value() 2984 if err != nil { 2985 return err 2986 } 2987 if val == nil { 2988 break 2989 } 2990 { 2991 xtv := string(val) 2992 i64, err := strconv.ParseInt(xtv, 10, 64) 2993 if err != nil { 2994 return err 2995 } 2996 mv = int32(i64) 2997 } 2998 sv = append(sv, mv) 2999 } 3000 *v = sv 3001 return nil 3002} 3003func awsEc2query_deserializeDocumentNestedStringList(v *[][]string, decoder smithyxml.NodeDecoder) error { 3004 if v == nil { 3005 return fmt.Errorf("unexpected nil of type %T", v) 3006 } 3007 var sv [][]string 3008 if *v == nil { 3009 sv = make([][]string, 0) 3010 } else { 3011 sv = *v 3012 } 3013 3014 originalDecoder := decoder 3015 for { 3016 t, done, err := decoder.Token() 3017 if err != nil { 3018 return err 3019 } 3020 if done { 3021 break 3022 } 3023 switch { 3024 case strings.EqualFold("member", t.Name.Local): 3025 var col []string 3026 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3027 if err := awsEc2query_deserializeDocumentStringList(&col, nodeDecoder); err != nil { 3028 return err 3029 } 3030 sv = append(sv, col) 3031 3032 default: 3033 err = decoder.Decoder.Skip() 3034 if err != nil { 3035 return err 3036 } 3037 3038 } 3039 decoder = originalDecoder 3040 } 3041 *v = sv 3042 return nil 3043} 3044 3045func awsEc2query_deserializeDocumentNestedStringListUnwrapped(v *[][]string, decoder smithyxml.NodeDecoder) error { 3046 var sv [][]string 3047 if *v == nil { 3048 sv = make([][]string, 0) 3049 } else { 3050 sv = *v 3051 } 3052 3053 switch { 3054 default: 3055 var mv []string 3056 t := decoder.StartEl 3057 _ = t 3058 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3059 if err := awsEc2query_deserializeDocumentStringList(&mv, nodeDecoder); err != nil { 3060 return err 3061 } 3062 sv = append(sv, mv) 3063 } 3064 *v = sv 3065 return nil 3066} 3067func awsEc2query_deserializeDocumentStringList(v *[]string, decoder smithyxml.NodeDecoder) error { 3068 if v == nil { 3069 return fmt.Errorf("unexpected nil of type %T", v) 3070 } 3071 var sv []string 3072 if *v == nil { 3073 sv = make([]string, 0) 3074 } else { 3075 sv = *v 3076 } 3077 3078 originalDecoder := decoder 3079 for { 3080 t, done, err := decoder.Token() 3081 if err != nil { 3082 return err 3083 } 3084 if done { 3085 break 3086 } 3087 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3088 decoder = memberDecoder 3089 switch { 3090 case strings.EqualFold("member", t.Name.Local): 3091 var col string 3092 val, err := decoder.Value() 3093 if err != nil { 3094 return err 3095 } 3096 if val == nil { 3097 break 3098 } 3099 { 3100 xtv := string(val) 3101 col = xtv 3102 } 3103 sv = append(sv, col) 3104 3105 default: 3106 err = decoder.Decoder.Skip() 3107 if err != nil { 3108 return err 3109 } 3110 3111 } 3112 decoder = originalDecoder 3113 } 3114 *v = sv 3115 return nil 3116} 3117 3118func awsEc2query_deserializeDocumentStringListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 3119 var sv []string 3120 if *v == nil { 3121 sv = make([]string, 0) 3122 } else { 3123 sv = *v 3124 } 3125 3126 switch { 3127 default: 3128 var mv string 3129 t := decoder.StartEl 3130 _ = t 3131 val, err := decoder.Value() 3132 if err != nil { 3133 return err 3134 } 3135 if val == nil { 3136 break 3137 } 3138 { 3139 xtv := string(val) 3140 mv = xtv 3141 } 3142 sv = append(sv, mv) 3143 } 3144 *v = sv 3145 return nil 3146} 3147func awsEc2query_deserializeDocumentStringSet(v *[]string, decoder smithyxml.NodeDecoder) error { 3148 if v == nil { 3149 return fmt.Errorf("unexpected nil of type %T", v) 3150 } 3151 var sv []string 3152 if *v == nil { 3153 sv = make([]string, 0) 3154 } else { 3155 sv = *v 3156 } 3157 3158 originalDecoder := decoder 3159 for { 3160 t, done, err := decoder.Token() 3161 if err != nil { 3162 return err 3163 } 3164 if done { 3165 break 3166 } 3167 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3168 decoder = memberDecoder 3169 switch { 3170 case strings.EqualFold("member", t.Name.Local): 3171 var col string 3172 val, err := decoder.Value() 3173 if err != nil { 3174 return err 3175 } 3176 if val == nil { 3177 break 3178 } 3179 { 3180 xtv := string(val) 3181 col = xtv 3182 } 3183 sv = append(sv, col) 3184 3185 default: 3186 err = decoder.Decoder.Skip() 3187 if err != nil { 3188 return err 3189 } 3190 3191 } 3192 decoder = originalDecoder 3193 } 3194 *v = sv 3195 return nil 3196} 3197 3198func awsEc2query_deserializeDocumentStringSetUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 3199 var sv []string 3200 if *v == nil { 3201 sv = make([]string, 0) 3202 } else { 3203 sv = *v 3204 } 3205 3206 switch { 3207 default: 3208 var mv string 3209 t := decoder.StartEl 3210 _ = t 3211 val, err := decoder.Value() 3212 if err != nil { 3213 return err 3214 } 3215 if val == nil { 3216 break 3217 } 3218 { 3219 xtv := string(val) 3220 mv = xtv 3221 } 3222 sv = append(sv, mv) 3223 } 3224 *v = sv 3225 return nil 3226} 3227func awsEc2query_deserializeDocumentTimestampList(v *[]time.Time, decoder smithyxml.NodeDecoder) error { 3228 if v == nil { 3229 return fmt.Errorf("unexpected nil of type %T", v) 3230 } 3231 var sv []time.Time 3232 if *v == nil { 3233 sv = make([]time.Time, 0) 3234 } else { 3235 sv = *v 3236 } 3237 3238 originalDecoder := decoder 3239 for { 3240 t, done, err := decoder.Token() 3241 if err != nil { 3242 return err 3243 } 3244 if done { 3245 break 3246 } 3247 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3248 decoder = memberDecoder 3249 switch { 3250 case strings.EqualFold("member", t.Name.Local): 3251 var col time.Time 3252 val, err := decoder.Value() 3253 if err != nil { 3254 return err 3255 } 3256 if val == nil { 3257 break 3258 } 3259 { 3260 xtv := string(val) 3261 t, err := smithytime.ParseDateTime(xtv) 3262 if err != nil { 3263 return err 3264 } 3265 col = t 3266 } 3267 sv = append(sv, col) 3268 3269 default: 3270 err = decoder.Decoder.Skip() 3271 if err != nil { 3272 return err 3273 } 3274 3275 } 3276 decoder = originalDecoder 3277 } 3278 *v = sv 3279 return nil 3280} 3281 3282func awsEc2query_deserializeDocumentTimestampListUnwrapped(v *[]time.Time, decoder smithyxml.NodeDecoder) error { 3283 var sv []time.Time 3284 if *v == nil { 3285 sv = make([]time.Time, 0) 3286 } else { 3287 sv = *v 3288 } 3289 3290 switch { 3291 default: 3292 var mv time.Time 3293 t := decoder.StartEl 3294 _ = t 3295 val, err := decoder.Value() 3296 if err != nil { 3297 return err 3298 } 3299 if val == nil { 3300 break 3301 } 3302 { 3303 xtv := string(val) 3304 t, err := smithytime.ParseDateTime(xtv) 3305 if err != nil { 3306 return err 3307 } 3308 mv = t 3309 } 3310 sv = append(sv, mv) 3311 } 3312 *v = sv 3313 return nil 3314} 3315func awsEc2query_deserializeOpDocumentEmptyInputAndEmptyOutputOutput(v **EmptyInputAndEmptyOutputOutput, decoder smithyxml.NodeDecoder) error { 3316 if v == nil { 3317 return fmt.Errorf("unexpected nil of type %T", v) 3318 } 3319 var sv *EmptyInputAndEmptyOutputOutput 3320 if *v == nil { 3321 sv = &EmptyInputAndEmptyOutputOutput{} 3322 } else { 3323 sv = *v 3324 } 3325 3326 for { 3327 t, done, err := decoder.Token() 3328 if err != nil { 3329 return err 3330 } 3331 if done { 3332 break 3333 } 3334 originalDecoder := decoder 3335 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3336 switch { 3337 default: 3338 // Do nothing and ignore the unexpected tag element 3339 err = decoder.Decoder.Skip() 3340 if err != nil { 3341 return err 3342 } 3343 3344 } 3345 decoder = originalDecoder 3346 } 3347 *v = sv 3348 return nil 3349} 3350 3351func awsEc2query_deserializeOpDocumentGreetingWithErrorsOutput(v **GreetingWithErrorsOutput, decoder smithyxml.NodeDecoder) error { 3352 if v == nil { 3353 return fmt.Errorf("unexpected nil of type %T", v) 3354 } 3355 var sv *GreetingWithErrorsOutput 3356 if *v == nil { 3357 sv = &GreetingWithErrorsOutput{} 3358 } else { 3359 sv = *v 3360 } 3361 3362 for { 3363 t, done, err := decoder.Token() 3364 if err != nil { 3365 return err 3366 } 3367 if done { 3368 break 3369 } 3370 originalDecoder := decoder 3371 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3372 switch { 3373 case strings.EqualFold("greeting", t.Name.Local): 3374 val, err := decoder.Value() 3375 if err != nil { 3376 return err 3377 } 3378 if val == nil { 3379 break 3380 } 3381 { 3382 xtv := string(val) 3383 sv.Greeting = ptr.String(xtv) 3384 } 3385 3386 default: 3387 // Do nothing and ignore the unexpected tag element 3388 err = decoder.Decoder.Skip() 3389 if err != nil { 3390 return err 3391 } 3392 3393 } 3394 decoder = originalDecoder 3395 } 3396 *v = sv 3397 return nil 3398} 3399 3400func awsEc2query_deserializeOpDocumentIgnoresWrappingXmlNameOutput(v **IgnoresWrappingXmlNameOutput, decoder smithyxml.NodeDecoder) error { 3401 if v == nil { 3402 return fmt.Errorf("unexpected nil of type %T", v) 3403 } 3404 var sv *IgnoresWrappingXmlNameOutput 3405 if *v == nil { 3406 sv = &IgnoresWrappingXmlNameOutput{} 3407 } else { 3408 sv = *v 3409 } 3410 3411 for { 3412 t, done, err := decoder.Token() 3413 if err != nil { 3414 return err 3415 } 3416 if done { 3417 break 3418 } 3419 originalDecoder := decoder 3420 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3421 switch { 3422 case strings.EqualFold("foo", t.Name.Local): 3423 val, err := decoder.Value() 3424 if err != nil { 3425 return err 3426 } 3427 if val == nil { 3428 break 3429 } 3430 { 3431 xtv := string(val) 3432 sv.Foo = ptr.String(xtv) 3433 } 3434 3435 default: 3436 // Do nothing and ignore the unexpected tag element 3437 err = decoder.Decoder.Skip() 3438 if err != nil { 3439 return err 3440 } 3441 3442 } 3443 decoder = originalDecoder 3444 } 3445 *v = sv 3446 return nil 3447} 3448 3449func awsEc2query_deserializeOpDocumentNoInputAndOutputOutput(v **NoInputAndOutputOutput, decoder smithyxml.NodeDecoder) error { 3450 if v == nil { 3451 return fmt.Errorf("unexpected nil of type %T", v) 3452 } 3453 var sv *NoInputAndOutputOutput 3454 if *v == nil { 3455 sv = &NoInputAndOutputOutput{} 3456 } else { 3457 sv = *v 3458 } 3459 3460 for { 3461 t, done, err := decoder.Token() 3462 if err != nil { 3463 return err 3464 } 3465 if done { 3466 break 3467 } 3468 originalDecoder := decoder 3469 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3470 switch { 3471 default: 3472 // Do nothing and ignore the unexpected tag element 3473 err = decoder.Decoder.Skip() 3474 if err != nil { 3475 return err 3476 } 3477 3478 } 3479 decoder = originalDecoder 3480 } 3481 *v = sv 3482 return nil 3483} 3484 3485func awsEc2query_deserializeOpDocumentRecursiveXmlShapesOutput(v **RecursiveXmlShapesOutput, decoder smithyxml.NodeDecoder) error { 3486 if v == nil { 3487 return fmt.Errorf("unexpected nil of type %T", v) 3488 } 3489 var sv *RecursiveXmlShapesOutput 3490 if *v == nil { 3491 sv = &RecursiveXmlShapesOutput{} 3492 } else { 3493 sv = *v 3494 } 3495 3496 for { 3497 t, done, err := decoder.Token() 3498 if err != nil { 3499 return err 3500 } 3501 if done { 3502 break 3503 } 3504 originalDecoder := decoder 3505 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3506 switch { 3507 case strings.EqualFold("nested", t.Name.Local): 3508 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3509 if err := awsEc2query_deserializeDocumentRecursiveXmlShapesOutputNested1(&sv.Nested, nodeDecoder); err != nil { 3510 return err 3511 } 3512 3513 default: 3514 // Do nothing and ignore the unexpected tag element 3515 err = decoder.Decoder.Skip() 3516 if err != nil { 3517 return err 3518 } 3519 3520 } 3521 decoder = originalDecoder 3522 } 3523 *v = sv 3524 return nil 3525} 3526 3527func awsEc2query_deserializeOpDocumentSimpleScalarXmlPropertiesOutput(v **SimpleScalarXmlPropertiesOutput, decoder smithyxml.NodeDecoder) error { 3528 if v == nil { 3529 return fmt.Errorf("unexpected nil of type %T", v) 3530 } 3531 var sv *SimpleScalarXmlPropertiesOutput 3532 if *v == nil { 3533 sv = &SimpleScalarXmlPropertiesOutput{} 3534 } else { 3535 sv = *v 3536 } 3537 3538 for { 3539 t, done, err := decoder.Token() 3540 if err != nil { 3541 return err 3542 } 3543 if done { 3544 break 3545 } 3546 originalDecoder := decoder 3547 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3548 switch { 3549 case strings.EqualFold("byteValue", t.Name.Local): 3550 val, err := decoder.Value() 3551 if err != nil { 3552 return err 3553 } 3554 if val == nil { 3555 break 3556 } 3557 { 3558 xtv := string(val) 3559 i64, err := strconv.ParseInt(xtv, 10, 64) 3560 if err != nil { 3561 return err 3562 } 3563 sv.ByteValue = ptr.Int8(int8(i64)) 3564 } 3565 3566 case strings.EqualFold("DoubleDribble", t.Name.Local): 3567 val, err := decoder.Value() 3568 if err != nil { 3569 return err 3570 } 3571 if val == nil { 3572 break 3573 } 3574 { 3575 xtv := string(val) 3576 f64, err := strconv.ParseFloat(xtv, 64) 3577 if err != nil { 3578 return err 3579 } 3580 sv.DoubleValue = ptr.Float64(f64) 3581 } 3582 3583 case strings.EqualFold("emptyStringValue", t.Name.Local): 3584 val, err := decoder.Value() 3585 if err != nil { 3586 return err 3587 } 3588 if val == nil { 3589 break 3590 } 3591 { 3592 xtv := string(val) 3593 sv.EmptyStringValue = ptr.String(xtv) 3594 } 3595 3596 case strings.EqualFold("falseBooleanValue", t.Name.Local): 3597 val, err := decoder.Value() 3598 if err != nil { 3599 return err 3600 } 3601 if val == nil { 3602 break 3603 } 3604 { 3605 xtv, err := strconv.ParseBool(string(val)) 3606 if err != nil { 3607 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 3608 } 3609 sv.FalseBooleanValue = ptr.Bool(xtv) 3610 } 3611 3612 case strings.EqualFold("floatValue", t.Name.Local): 3613 val, err := decoder.Value() 3614 if err != nil { 3615 return err 3616 } 3617 if val == nil { 3618 break 3619 } 3620 { 3621 xtv := string(val) 3622 f64, err := strconv.ParseFloat(xtv, 64) 3623 if err != nil { 3624 return err 3625 } 3626 sv.FloatValue = ptr.Float32(float32(f64)) 3627 } 3628 3629 case strings.EqualFold("integerValue", t.Name.Local): 3630 val, err := decoder.Value() 3631 if err != nil { 3632 return err 3633 } 3634 if val == nil { 3635 break 3636 } 3637 { 3638 xtv := string(val) 3639 i64, err := strconv.ParseInt(xtv, 10, 64) 3640 if err != nil { 3641 return err 3642 } 3643 sv.IntegerValue = ptr.Int32(int32(i64)) 3644 } 3645 3646 case strings.EqualFold("longValue", t.Name.Local): 3647 val, err := decoder.Value() 3648 if err != nil { 3649 return err 3650 } 3651 if val == nil { 3652 break 3653 } 3654 { 3655 xtv := string(val) 3656 i64, err := strconv.ParseInt(xtv, 10, 64) 3657 if err != nil { 3658 return err 3659 } 3660 sv.LongValue = ptr.Int64(i64) 3661 } 3662 3663 case strings.EqualFold("shortValue", t.Name.Local): 3664 val, err := decoder.Value() 3665 if err != nil { 3666 return err 3667 } 3668 if val == nil { 3669 break 3670 } 3671 { 3672 xtv := string(val) 3673 i64, err := strconv.ParseInt(xtv, 10, 64) 3674 if err != nil { 3675 return err 3676 } 3677 sv.ShortValue = ptr.Int16(int16(i64)) 3678 } 3679 3680 case strings.EqualFold("stringValue", t.Name.Local): 3681 val, err := decoder.Value() 3682 if err != nil { 3683 return err 3684 } 3685 if val == nil { 3686 break 3687 } 3688 { 3689 xtv := string(val) 3690 sv.StringValue = ptr.String(xtv) 3691 } 3692 3693 case strings.EqualFold("trueBooleanValue", t.Name.Local): 3694 val, err := decoder.Value() 3695 if err != nil { 3696 return err 3697 } 3698 if val == nil { 3699 break 3700 } 3701 { 3702 xtv, err := strconv.ParseBool(string(val)) 3703 if err != nil { 3704 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 3705 } 3706 sv.TrueBooleanValue = ptr.Bool(xtv) 3707 } 3708 3709 default: 3710 // Do nothing and ignore the unexpected tag element 3711 err = decoder.Decoder.Skip() 3712 if err != nil { 3713 return err 3714 } 3715 3716 } 3717 decoder = originalDecoder 3718 } 3719 *v = sv 3720 return nil 3721} 3722 3723func awsEc2query_deserializeOpDocumentXmlBlobsOutput(v **XmlBlobsOutput, decoder smithyxml.NodeDecoder) error { 3724 if v == nil { 3725 return fmt.Errorf("unexpected nil of type %T", v) 3726 } 3727 var sv *XmlBlobsOutput 3728 if *v == nil { 3729 sv = &XmlBlobsOutput{} 3730 } else { 3731 sv = *v 3732 } 3733 3734 for { 3735 t, done, err := decoder.Token() 3736 if err != nil { 3737 return err 3738 } 3739 if done { 3740 break 3741 } 3742 originalDecoder := decoder 3743 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3744 switch { 3745 case strings.EqualFold("data", t.Name.Local): 3746 var data string 3747 val, err := decoder.Value() 3748 if err != nil { 3749 return err 3750 } 3751 if val == nil { 3752 break 3753 } 3754 { 3755 xtv := string(val) 3756 data = xtv 3757 } 3758 sv.Data, err = base64.StdEncoding.DecodeString(data) 3759 if err != nil { 3760 return err 3761 } 3762 3763 default: 3764 // Do nothing and ignore the unexpected tag element 3765 err = decoder.Decoder.Skip() 3766 if err != nil { 3767 return err 3768 } 3769 3770 } 3771 decoder = originalDecoder 3772 } 3773 *v = sv 3774 return nil 3775} 3776 3777func awsEc2query_deserializeOpDocumentXmlEmptyBlobsOutput(v **XmlEmptyBlobsOutput, decoder smithyxml.NodeDecoder) error { 3778 if v == nil { 3779 return fmt.Errorf("unexpected nil of type %T", v) 3780 } 3781 var sv *XmlEmptyBlobsOutput 3782 if *v == nil { 3783 sv = &XmlEmptyBlobsOutput{} 3784 } else { 3785 sv = *v 3786 } 3787 3788 for { 3789 t, done, err := decoder.Token() 3790 if err != nil { 3791 return err 3792 } 3793 if done { 3794 break 3795 } 3796 originalDecoder := decoder 3797 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3798 switch { 3799 case strings.EqualFold("data", t.Name.Local): 3800 var data string 3801 val, err := decoder.Value() 3802 if err != nil { 3803 return err 3804 } 3805 if val == nil { 3806 break 3807 } 3808 { 3809 xtv := string(val) 3810 data = xtv 3811 } 3812 sv.Data, err = base64.StdEncoding.DecodeString(data) 3813 if err != nil { 3814 return err 3815 } 3816 3817 default: 3818 // Do nothing and ignore the unexpected tag element 3819 err = decoder.Decoder.Skip() 3820 if err != nil { 3821 return err 3822 } 3823 3824 } 3825 decoder = originalDecoder 3826 } 3827 *v = sv 3828 return nil 3829} 3830 3831func awsEc2query_deserializeOpDocumentXmlEmptyListsOutput(v **XmlEmptyListsOutput, decoder smithyxml.NodeDecoder) error { 3832 if v == nil { 3833 return fmt.Errorf("unexpected nil of type %T", v) 3834 } 3835 var sv *XmlEmptyListsOutput 3836 if *v == nil { 3837 sv = &XmlEmptyListsOutput{} 3838 } else { 3839 sv = *v 3840 } 3841 3842 for { 3843 t, done, err := decoder.Token() 3844 if err != nil { 3845 return err 3846 } 3847 if done { 3848 break 3849 } 3850 originalDecoder := decoder 3851 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3852 switch { 3853 case strings.EqualFold("booleanList", t.Name.Local): 3854 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3855 if err := awsEc2query_deserializeDocumentBooleanList(&sv.BooleanList, nodeDecoder); err != nil { 3856 return err 3857 } 3858 3859 case strings.EqualFold("enumList", t.Name.Local): 3860 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3861 if err := awsEc2query_deserializeDocumentFooEnumList(&sv.EnumList, nodeDecoder); err != nil { 3862 return err 3863 } 3864 3865 case strings.EqualFold("flattenedList", t.Name.Local): 3866 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3867 if err := awsEc2query_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList, nodeDecoder); err != nil { 3868 return err 3869 } 3870 3871 case strings.EqualFold("customName", t.Name.Local): 3872 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3873 if err := awsEc2query_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList2, nodeDecoder); err != nil { 3874 return err 3875 } 3876 3877 case strings.EqualFold("flattenedListWithMemberNamespace", t.Name.Local): 3878 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3879 if err := awsEc2query_deserializeDocumentListWithMemberNamespaceUnwrapped(&sv.FlattenedListWithMemberNamespace, nodeDecoder); err != nil { 3880 return err 3881 } 3882 3883 case strings.EqualFold("flattenedListWithNamespace", t.Name.Local): 3884 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3885 if err := awsEc2query_deserializeDocumentListWithNamespaceUnwrapped(&sv.FlattenedListWithNamespace, nodeDecoder); err != nil { 3886 return err 3887 } 3888 3889 case strings.EqualFold("integerList", t.Name.Local): 3890 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3891 if err := awsEc2query_deserializeDocumentIntegerList(&sv.IntegerList, nodeDecoder); err != nil { 3892 return err 3893 } 3894 3895 case strings.EqualFold("nestedStringList", t.Name.Local): 3896 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3897 if err := awsEc2query_deserializeDocumentNestedStringList(&sv.NestedStringList, nodeDecoder); err != nil { 3898 return err 3899 } 3900 3901 case strings.EqualFold("renamed", t.Name.Local): 3902 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3903 if err := awsEc2query_deserializeDocumentRenamedListMembers(&sv.RenamedListMembers, nodeDecoder); err != nil { 3904 return err 3905 } 3906 3907 case strings.EqualFold("stringList", t.Name.Local): 3908 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3909 if err := awsEc2query_deserializeDocumentStringList(&sv.StringList, nodeDecoder); err != nil { 3910 return err 3911 } 3912 3913 case strings.EqualFold("stringSet", t.Name.Local): 3914 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3915 if err := awsEc2query_deserializeDocumentStringSet(&sv.StringSet, nodeDecoder); err != nil { 3916 return err 3917 } 3918 3919 case strings.EqualFold("myStructureList", t.Name.Local): 3920 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3921 if err := awsEc2query_deserializeDocumentStructureList(&sv.StructureList, nodeDecoder); err != nil { 3922 return err 3923 } 3924 3925 case strings.EqualFold("timestampList", t.Name.Local): 3926 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3927 if err := awsEc2query_deserializeDocumentTimestampList(&sv.TimestampList, nodeDecoder); err != nil { 3928 return err 3929 } 3930 3931 default: 3932 // Do nothing and ignore the unexpected tag element 3933 err = decoder.Decoder.Skip() 3934 if err != nil { 3935 return err 3936 } 3937 3938 } 3939 decoder = originalDecoder 3940 } 3941 *v = sv 3942 return nil 3943} 3944 3945func awsEc2query_deserializeOpDocumentXmlEnumsOutput(v **XmlEnumsOutput, decoder smithyxml.NodeDecoder) error { 3946 if v == nil { 3947 return fmt.Errorf("unexpected nil of type %T", v) 3948 } 3949 var sv *XmlEnumsOutput 3950 if *v == nil { 3951 sv = &XmlEnumsOutput{} 3952 } else { 3953 sv = *v 3954 } 3955 3956 for { 3957 t, done, err := decoder.Token() 3958 if err != nil { 3959 return err 3960 } 3961 if done { 3962 break 3963 } 3964 originalDecoder := decoder 3965 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3966 switch { 3967 case strings.EqualFold("fooEnum1", t.Name.Local): 3968 val, err := decoder.Value() 3969 if err != nil { 3970 return err 3971 } 3972 if val == nil { 3973 break 3974 } 3975 { 3976 xtv := string(val) 3977 sv.FooEnum1 = types.FooEnum(xtv) 3978 } 3979 3980 case strings.EqualFold("fooEnum2", t.Name.Local): 3981 val, err := decoder.Value() 3982 if err != nil { 3983 return err 3984 } 3985 if val == nil { 3986 break 3987 } 3988 { 3989 xtv := string(val) 3990 sv.FooEnum2 = types.FooEnum(xtv) 3991 } 3992 3993 case strings.EqualFold("fooEnum3", t.Name.Local): 3994 val, err := decoder.Value() 3995 if err != nil { 3996 return err 3997 } 3998 if val == nil { 3999 break 4000 } 4001 { 4002 xtv := string(val) 4003 sv.FooEnum3 = types.FooEnum(xtv) 4004 } 4005 4006 case strings.EqualFold("fooEnumList", t.Name.Local): 4007 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4008 if err := awsEc2query_deserializeDocumentFooEnumList(&sv.FooEnumList, nodeDecoder); err != nil { 4009 return err 4010 } 4011 4012 case strings.EqualFold("fooEnumMap", t.Name.Local): 4013 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4014 if err := awsEc2query_deserializeDocumentFooEnumMap(&sv.FooEnumMap, nodeDecoder); err != nil { 4015 return err 4016 } 4017 4018 case strings.EqualFold("fooEnumSet", t.Name.Local): 4019 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4020 if err := awsEc2query_deserializeDocumentFooEnumSet(&sv.FooEnumSet, nodeDecoder); err != nil { 4021 return err 4022 } 4023 4024 default: 4025 // Do nothing and ignore the unexpected tag element 4026 err = decoder.Decoder.Skip() 4027 if err != nil { 4028 return err 4029 } 4030 4031 } 4032 decoder = originalDecoder 4033 } 4034 *v = sv 4035 return nil 4036} 4037 4038func awsEc2query_deserializeOpDocumentXmlListsOutput(v **XmlListsOutput, decoder smithyxml.NodeDecoder) error { 4039 if v == nil { 4040 return fmt.Errorf("unexpected nil of type %T", v) 4041 } 4042 var sv *XmlListsOutput 4043 if *v == nil { 4044 sv = &XmlListsOutput{} 4045 } else { 4046 sv = *v 4047 } 4048 4049 for { 4050 t, done, err := decoder.Token() 4051 if err != nil { 4052 return err 4053 } 4054 if done { 4055 break 4056 } 4057 originalDecoder := decoder 4058 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4059 switch { 4060 case strings.EqualFold("booleanList", t.Name.Local): 4061 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4062 if err := awsEc2query_deserializeDocumentBooleanList(&sv.BooleanList, nodeDecoder); err != nil { 4063 return err 4064 } 4065 4066 case strings.EqualFold("enumList", t.Name.Local): 4067 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4068 if err := awsEc2query_deserializeDocumentFooEnumList(&sv.EnumList, nodeDecoder); err != nil { 4069 return err 4070 } 4071 4072 case strings.EqualFold("flattenedList", t.Name.Local): 4073 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4074 if err := awsEc2query_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList, nodeDecoder); err != nil { 4075 return err 4076 } 4077 4078 case strings.EqualFold("customName", t.Name.Local): 4079 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4080 if err := awsEc2query_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList2, nodeDecoder); err != nil { 4081 return err 4082 } 4083 4084 case strings.EqualFold("flattenedListWithMemberNamespace", t.Name.Local): 4085 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4086 if err := awsEc2query_deserializeDocumentListWithMemberNamespaceUnwrapped(&sv.FlattenedListWithMemberNamespace, nodeDecoder); err != nil { 4087 return err 4088 } 4089 4090 case strings.EqualFold("flattenedListWithNamespace", t.Name.Local): 4091 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4092 if err := awsEc2query_deserializeDocumentListWithNamespaceUnwrapped(&sv.FlattenedListWithNamespace, nodeDecoder); err != nil { 4093 return err 4094 } 4095 4096 case strings.EqualFold("integerList", t.Name.Local): 4097 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4098 if err := awsEc2query_deserializeDocumentIntegerList(&sv.IntegerList, nodeDecoder); err != nil { 4099 return err 4100 } 4101 4102 case strings.EqualFold("nestedStringList", t.Name.Local): 4103 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4104 if err := awsEc2query_deserializeDocumentNestedStringList(&sv.NestedStringList, nodeDecoder); err != nil { 4105 return err 4106 } 4107 4108 case strings.EqualFold("renamed", t.Name.Local): 4109 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4110 if err := awsEc2query_deserializeDocumentRenamedListMembers(&sv.RenamedListMembers, nodeDecoder); err != nil { 4111 return err 4112 } 4113 4114 case strings.EqualFold("stringList", t.Name.Local): 4115 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4116 if err := awsEc2query_deserializeDocumentStringList(&sv.StringList, nodeDecoder); err != nil { 4117 return err 4118 } 4119 4120 case strings.EqualFold("stringSet", t.Name.Local): 4121 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4122 if err := awsEc2query_deserializeDocumentStringSet(&sv.StringSet, nodeDecoder); err != nil { 4123 return err 4124 } 4125 4126 case strings.EqualFold("myStructureList", t.Name.Local): 4127 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4128 if err := awsEc2query_deserializeDocumentStructureList(&sv.StructureList, nodeDecoder); err != nil { 4129 return err 4130 } 4131 4132 case strings.EqualFold("timestampList", t.Name.Local): 4133 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4134 if err := awsEc2query_deserializeDocumentTimestampList(&sv.TimestampList, nodeDecoder); err != nil { 4135 return err 4136 } 4137 4138 default: 4139 // Do nothing and ignore the unexpected tag element 4140 err = decoder.Decoder.Skip() 4141 if err != nil { 4142 return err 4143 } 4144 4145 } 4146 decoder = originalDecoder 4147 } 4148 *v = sv 4149 return nil 4150} 4151 4152func awsEc2query_deserializeOpDocumentXmlNamespacesOutput(v **XmlNamespacesOutput, decoder smithyxml.NodeDecoder) error { 4153 if v == nil { 4154 return fmt.Errorf("unexpected nil of type %T", v) 4155 } 4156 var sv *XmlNamespacesOutput 4157 if *v == nil { 4158 sv = &XmlNamespacesOutput{} 4159 } else { 4160 sv = *v 4161 } 4162 4163 for { 4164 t, done, err := decoder.Token() 4165 if err != nil { 4166 return err 4167 } 4168 if done { 4169 break 4170 } 4171 originalDecoder := decoder 4172 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4173 switch { 4174 case strings.EqualFold("nested", t.Name.Local): 4175 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4176 if err := awsEc2query_deserializeDocumentXmlNamespaceNested(&sv.Nested, nodeDecoder); err != nil { 4177 return err 4178 } 4179 4180 default: 4181 // Do nothing and ignore the unexpected tag element 4182 err = decoder.Decoder.Skip() 4183 if err != nil { 4184 return err 4185 } 4186 4187 } 4188 decoder = originalDecoder 4189 } 4190 *v = sv 4191 return nil 4192} 4193 4194func awsEc2query_deserializeOpDocumentXmlTimestampsOutput(v **XmlTimestampsOutput, decoder smithyxml.NodeDecoder) error { 4195 if v == nil { 4196 return fmt.Errorf("unexpected nil of type %T", v) 4197 } 4198 var sv *XmlTimestampsOutput 4199 if *v == nil { 4200 sv = &XmlTimestampsOutput{} 4201 } else { 4202 sv = *v 4203 } 4204 4205 for { 4206 t, done, err := decoder.Token() 4207 if err != nil { 4208 return err 4209 } 4210 if done { 4211 break 4212 } 4213 originalDecoder := decoder 4214 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4215 switch { 4216 case strings.EqualFold("dateTime", t.Name.Local): 4217 val, err := decoder.Value() 4218 if err != nil { 4219 return err 4220 } 4221 if val == nil { 4222 break 4223 } 4224 { 4225 xtv := string(val) 4226 t, err := smithytime.ParseDateTime(xtv) 4227 if err != nil { 4228 return err 4229 } 4230 sv.DateTime = ptr.Time(t) 4231 } 4232 4233 case strings.EqualFold("epochSeconds", t.Name.Local): 4234 val, err := decoder.Value() 4235 if err != nil { 4236 return err 4237 } 4238 if val == nil { 4239 break 4240 } 4241 { 4242 xtv := string(val) 4243 f64, err := strconv.ParseFloat(xtv, 64) 4244 if err != nil { 4245 return err 4246 } 4247 sv.EpochSeconds = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4248 } 4249 4250 case strings.EqualFold("httpDate", t.Name.Local): 4251 val, err := decoder.Value() 4252 if err != nil { 4253 return err 4254 } 4255 if val == nil { 4256 break 4257 } 4258 { 4259 xtv := string(val) 4260 t, err := smithytime.ParseHTTPDate(xtv) 4261 if err != nil { 4262 return err 4263 } 4264 sv.HttpDate = ptr.Time(t) 4265 } 4266 4267 case strings.EqualFold("normal", t.Name.Local): 4268 val, err := decoder.Value() 4269 if err != nil { 4270 return err 4271 } 4272 if val == nil { 4273 break 4274 } 4275 { 4276 xtv := string(val) 4277 t, err := smithytime.ParseDateTime(xtv) 4278 if err != nil { 4279 return err 4280 } 4281 sv.Normal = ptr.Time(t) 4282 } 4283 4284 default: 4285 // Do nothing and ignore the unexpected tag element 4286 err = decoder.Decoder.Skip() 4287 if err != nil { 4288 return err 4289 } 4290 4291 } 4292 decoder = originalDecoder 4293 } 4294 *v = sv 4295 return nil 4296} 4297