1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package restxml 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 awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml" 13 "github.com/aws/aws-sdk-go-v2/internal/protocoltest/restxml/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 awsRestxml_deserializeOpAllQueryStringTypes struct { 29} 30 31func (*awsRestxml_deserializeOpAllQueryStringTypes) ID() string { 32 return "OperationDeserializer" 33} 34 35func (m *awsRestxml_deserializeOpAllQueryStringTypes) 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, awsRestxml_deserializeOpErrorAllQueryStringTypes(response, &metadata) 50 } 51 output := &AllQueryStringTypesOutput{} 52 out.Result = output 53 54 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 55 return out, metadata, &smithy.DeserializationError{ 56 Err: fmt.Errorf("failed to discard response body, %w", err), 57 } 58 } 59 60 return out, metadata, err 61} 62 63func awsRestxml_deserializeOpErrorAllQueryStringTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 64 var errorBuffer bytes.Buffer 65 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 66 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 67 } 68 errorBody := bytes.NewReader(errorBuffer.Bytes()) 69 70 errorCode := "UnknownError" 71 errorMessage := errorCode 72 73 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 74 if err != nil { 75 return err 76 } 77 if reqID := errorComponents.RequestID; len(reqID) != 0 { 78 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 79 } 80 if len(errorComponents.Code) != 0 { 81 errorCode = errorComponents.Code 82 } 83 if len(errorComponents.Message) != 0 { 84 errorMessage = errorComponents.Message 85 } 86 errorBody.Seek(0, io.SeekStart) 87 switch { 88 default: 89 genericError := &smithy.GenericAPIError{ 90 Code: errorCode, 91 Message: errorMessage, 92 } 93 return genericError 94 95 } 96} 97 98type awsRestxml_deserializeOpConstantAndVariableQueryString struct { 99} 100 101func (*awsRestxml_deserializeOpConstantAndVariableQueryString) ID() string { 102 return "OperationDeserializer" 103} 104 105func (m *awsRestxml_deserializeOpConstantAndVariableQueryString) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 106 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 107) { 108 out, metadata, err = next.HandleDeserialize(ctx, in) 109 if err != nil { 110 return out, metadata, err 111 } 112 113 response, ok := out.RawResponse.(*smithyhttp.Response) 114 if !ok { 115 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 116 } 117 118 if response.StatusCode < 200 || response.StatusCode >= 300 { 119 return out, metadata, awsRestxml_deserializeOpErrorConstantAndVariableQueryString(response, &metadata) 120 } 121 output := &ConstantAndVariableQueryStringOutput{} 122 out.Result = output 123 124 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 125 return out, metadata, &smithy.DeserializationError{ 126 Err: fmt.Errorf("failed to discard response body, %w", err), 127 } 128 } 129 130 return out, metadata, err 131} 132 133func awsRestxml_deserializeOpErrorConstantAndVariableQueryString(response *smithyhttp.Response, metadata *middleware.Metadata) error { 134 var errorBuffer bytes.Buffer 135 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 136 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 137 } 138 errorBody := bytes.NewReader(errorBuffer.Bytes()) 139 140 errorCode := "UnknownError" 141 errorMessage := errorCode 142 143 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 144 if err != nil { 145 return err 146 } 147 if reqID := errorComponents.RequestID; len(reqID) != 0 { 148 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 149 } 150 if len(errorComponents.Code) != 0 { 151 errorCode = errorComponents.Code 152 } 153 if len(errorComponents.Message) != 0 { 154 errorMessage = errorComponents.Message 155 } 156 errorBody.Seek(0, io.SeekStart) 157 switch { 158 default: 159 genericError := &smithy.GenericAPIError{ 160 Code: errorCode, 161 Message: errorMessage, 162 } 163 return genericError 164 165 } 166} 167 168type awsRestxml_deserializeOpConstantQueryString struct { 169} 170 171func (*awsRestxml_deserializeOpConstantQueryString) ID() string { 172 return "OperationDeserializer" 173} 174 175func (m *awsRestxml_deserializeOpConstantQueryString) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 176 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 177) { 178 out, metadata, err = next.HandleDeserialize(ctx, in) 179 if err != nil { 180 return out, metadata, err 181 } 182 183 response, ok := out.RawResponse.(*smithyhttp.Response) 184 if !ok { 185 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 186 } 187 188 if response.StatusCode < 200 || response.StatusCode >= 300 { 189 return out, metadata, awsRestxml_deserializeOpErrorConstantQueryString(response, &metadata) 190 } 191 output := &ConstantQueryStringOutput{} 192 out.Result = output 193 194 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 195 return out, metadata, &smithy.DeserializationError{ 196 Err: fmt.Errorf("failed to discard response body, %w", err), 197 } 198 } 199 200 return out, metadata, err 201} 202 203func awsRestxml_deserializeOpErrorConstantQueryString(response *smithyhttp.Response, metadata *middleware.Metadata) error { 204 var errorBuffer bytes.Buffer 205 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 206 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 207 } 208 errorBody := bytes.NewReader(errorBuffer.Bytes()) 209 210 errorCode := "UnknownError" 211 errorMessage := errorCode 212 213 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 214 if err != nil { 215 return err 216 } 217 if reqID := errorComponents.RequestID; len(reqID) != 0 { 218 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 219 } 220 if len(errorComponents.Code) != 0 { 221 errorCode = errorComponents.Code 222 } 223 if len(errorComponents.Message) != 0 { 224 errorMessage = errorComponents.Message 225 } 226 errorBody.Seek(0, io.SeekStart) 227 switch { 228 default: 229 genericError := &smithy.GenericAPIError{ 230 Code: errorCode, 231 Message: errorMessage, 232 } 233 return genericError 234 235 } 236} 237 238type awsRestxml_deserializeOpEmptyInputAndEmptyOutput struct { 239} 240 241func (*awsRestxml_deserializeOpEmptyInputAndEmptyOutput) ID() string { 242 return "OperationDeserializer" 243} 244 245func (m *awsRestxml_deserializeOpEmptyInputAndEmptyOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 246 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 247) { 248 out, metadata, err = next.HandleDeserialize(ctx, in) 249 if err != nil { 250 return out, metadata, err 251 } 252 253 response, ok := out.RawResponse.(*smithyhttp.Response) 254 if !ok { 255 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 256 } 257 258 if response.StatusCode < 200 || response.StatusCode >= 300 { 259 return out, metadata, awsRestxml_deserializeOpErrorEmptyInputAndEmptyOutput(response, &metadata) 260 } 261 output := &EmptyInputAndEmptyOutputOutput{} 262 out.Result = output 263 264 return out, metadata, err 265} 266 267func awsRestxml_deserializeOpErrorEmptyInputAndEmptyOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 268 var errorBuffer bytes.Buffer 269 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 270 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 271 } 272 errorBody := bytes.NewReader(errorBuffer.Bytes()) 273 274 errorCode := "UnknownError" 275 errorMessage := errorCode 276 277 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 278 if err != nil { 279 return err 280 } 281 if reqID := errorComponents.RequestID; len(reqID) != 0 { 282 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 283 } 284 if len(errorComponents.Code) != 0 { 285 errorCode = errorComponents.Code 286 } 287 if len(errorComponents.Message) != 0 { 288 errorMessage = errorComponents.Message 289 } 290 errorBody.Seek(0, io.SeekStart) 291 switch { 292 default: 293 genericError := &smithy.GenericAPIError{ 294 Code: errorCode, 295 Message: errorMessage, 296 } 297 return genericError 298 299 } 300} 301 302type awsRestxml_deserializeOpEndpointOperation struct { 303} 304 305func (*awsRestxml_deserializeOpEndpointOperation) ID() string { 306 return "OperationDeserializer" 307} 308 309func (m *awsRestxml_deserializeOpEndpointOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 310 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 311) { 312 out, metadata, err = next.HandleDeserialize(ctx, in) 313 if err != nil { 314 return out, metadata, err 315 } 316 317 response, ok := out.RawResponse.(*smithyhttp.Response) 318 if !ok { 319 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 320 } 321 322 if response.StatusCode < 200 || response.StatusCode >= 300 { 323 return out, metadata, awsRestxml_deserializeOpErrorEndpointOperation(response, &metadata) 324 } 325 output := &EndpointOperationOutput{} 326 out.Result = output 327 328 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 329 return out, metadata, &smithy.DeserializationError{ 330 Err: fmt.Errorf("failed to discard response body, %w", err), 331 } 332 } 333 334 return out, metadata, err 335} 336 337func awsRestxml_deserializeOpErrorEndpointOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 338 var errorBuffer bytes.Buffer 339 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 340 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 341 } 342 errorBody := bytes.NewReader(errorBuffer.Bytes()) 343 344 errorCode := "UnknownError" 345 errorMessage := errorCode 346 347 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 348 if err != nil { 349 return err 350 } 351 if reqID := errorComponents.RequestID; len(reqID) != 0 { 352 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 353 } 354 if len(errorComponents.Code) != 0 { 355 errorCode = errorComponents.Code 356 } 357 if len(errorComponents.Message) != 0 { 358 errorMessage = errorComponents.Message 359 } 360 errorBody.Seek(0, io.SeekStart) 361 switch { 362 default: 363 genericError := &smithy.GenericAPIError{ 364 Code: errorCode, 365 Message: errorMessage, 366 } 367 return genericError 368 369 } 370} 371 372type awsRestxml_deserializeOpEndpointWithHostLabelHeaderOperation struct { 373} 374 375func (*awsRestxml_deserializeOpEndpointWithHostLabelHeaderOperation) ID() string { 376 return "OperationDeserializer" 377} 378 379func (m *awsRestxml_deserializeOpEndpointWithHostLabelHeaderOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 380 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 381) { 382 out, metadata, err = next.HandleDeserialize(ctx, in) 383 if err != nil { 384 return out, metadata, err 385 } 386 387 response, ok := out.RawResponse.(*smithyhttp.Response) 388 if !ok { 389 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 390 } 391 392 if response.StatusCode < 200 || response.StatusCode >= 300 { 393 return out, metadata, awsRestxml_deserializeOpErrorEndpointWithHostLabelHeaderOperation(response, &metadata) 394 } 395 output := &EndpointWithHostLabelHeaderOperationOutput{} 396 out.Result = output 397 398 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 399 return out, metadata, &smithy.DeserializationError{ 400 Err: fmt.Errorf("failed to discard response body, %w", err), 401 } 402 } 403 404 return out, metadata, err 405} 406 407func awsRestxml_deserializeOpErrorEndpointWithHostLabelHeaderOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 408 var errorBuffer bytes.Buffer 409 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 410 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 411 } 412 errorBody := bytes.NewReader(errorBuffer.Bytes()) 413 414 errorCode := "UnknownError" 415 errorMessage := errorCode 416 417 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 418 if err != nil { 419 return err 420 } 421 if reqID := errorComponents.RequestID; len(reqID) != 0 { 422 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 423 } 424 if len(errorComponents.Code) != 0 { 425 errorCode = errorComponents.Code 426 } 427 if len(errorComponents.Message) != 0 { 428 errorMessage = errorComponents.Message 429 } 430 errorBody.Seek(0, io.SeekStart) 431 switch { 432 default: 433 genericError := &smithy.GenericAPIError{ 434 Code: errorCode, 435 Message: errorMessage, 436 } 437 return genericError 438 439 } 440} 441 442type awsRestxml_deserializeOpEndpointWithHostLabelOperation struct { 443} 444 445func (*awsRestxml_deserializeOpEndpointWithHostLabelOperation) ID() string { 446 return "OperationDeserializer" 447} 448 449func (m *awsRestxml_deserializeOpEndpointWithHostLabelOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 450 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 451) { 452 out, metadata, err = next.HandleDeserialize(ctx, in) 453 if err != nil { 454 return out, metadata, err 455 } 456 457 response, ok := out.RawResponse.(*smithyhttp.Response) 458 if !ok { 459 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 460 } 461 462 if response.StatusCode < 200 || response.StatusCode >= 300 { 463 return out, metadata, awsRestxml_deserializeOpErrorEndpointWithHostLabelOperation(response, &metadata) 464 } 465 output := &EndpointWithHostLabelOperationOutput{} 466 out.Result = output 467 468 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 469 return out, metadata, &smithy.DeserializationError{ 470 Err: fmt.Errorf("failed to discard response body, %w", err), 471 } 472 } 473 474 return out, metadata, err 475} 476 477func awsRestxml_deserializeOpErrorEndpointWithHostLabelOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 478 var errorBuffer bytes.Buffer 479 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 480 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 481 } 482 errorBody := bytes.NewReader(errorBuffer.Bytes()) 483 484 errorCode := "UnknownError" 485 errorMessage := errorCode 486 487 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 488 if err != nil { 489 return err 490 } 491 if reqID := errorComponents.RequestID; len(reqID) != 0 { 492 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 493 } 494 if len(errorComponents.Code) != 0 { 495 errorCode = errorComponents.Code 496 } 497 if len(errorComponents.Message) != 0 { 498 errorMessage = errorComponents.Message 499 } 500 errorBody.Seek(0, io.SeekStart) 501 switch { 502 default: 503 genericError := &smithy.GenericAPIError{ 504 Code: errorCode, 505 Message: errorMessage, 506 } 507 return genericError 508 509 } 510} 511 512type awsRestxml_deserializeOpFlattenedXmlMap struct { 513} 514 515func (*awsRestxml_deserializeOpFlattenedXmlMap) ID() string { 516 return "OperationDeserializer" 517} 518 519func (m *awsRestxml_deserializeOpFlattenedXmlMap) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 520 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 521) { 522 out, metadata, err = next.HandleDeserialize(ctx, in) 523 if err != nil { 524 return out, metadata, err 525 } 526 527 response, ok := out.RawResponse.(*smithyhttp.Response) 528 if !ok { 529 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 530 } 531 532 if response.StatusCode < 200 || response.StatusCode >= 300 { 533 return out, metadata, awsRestxml_deserializeOpErrorFlattenedXmlMap(response, &metadata) 534 } 535 output := &FlattenedXmlMapOutput{} 536 out.Result = output 537 538 var buff [1024]byte 539 ringBuffer := smithyio.NewRingBuffer(buff[:]) 540 body := io.TeeReader(response.Body, ringBuffer) 541 rootDecoder := xml.NewDecoder(body) 542 t, err := smithyxml.FetchRootElement(rootDecoder) 543 if err == io.EOF { 544 return out, metadata, nil 545 } 546 if err != nil { 547 var snapshot bytes.Buffer 548 io.Copy(&snapshot, ringBuffer) 549 return out, metadata, &smithy.DeserializationError{ 550 Err: fmt.Errorf("failed to decode response body, %w", err), 551 Snapshot: snapshot.Bytes(), 552 } 553 } 554 555 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 556 err = awsRestxml_deserializeOpDocumentFlattenedXmlMapOutput(&output, decoder) 557 if err != nil { 558 var snapshot bytes.Buffer 559 io.Copy(&snapshot, ringBuffer) 560 return out, metadata, &smithy.DeserializationError{ 561 Err: fmt.Errorf("failed to decode response body, %w", err), 562 Snapshot: snapshot.Bytes(), 563 } 564 } 565 566 return out, metadata, err 567} 568 569func awsRestxml_deserializeOpErrorFlattenedXmlMap(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 := awsxml.GetErrorResponseComponents(errorBody, false) 580 if err != nil { 581 return err 582 } 583 if reqID := errorComponents.RequestID; len(reqID) != 0 { 584 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 585 } 586 if len(errorComponents.Code) != 0 { 587 errorCode = errorComponents.Code 588 } 589 if len(errorComponents.Message) != 0 { 590 errorMessage = errorComponents.Message 591 } 592 errorBody.Seek(0, io.SeekStart) 593 switch { 594 default: 595 genericError := &smithy.GenericAPIError{ 596 Code: errorCode, 597 Message: errorMessage, 598 } 599 return genericError 600 601 } 602} 603 604func awsRestxml_deserializeOpDocumentFlattenedXmlMapOutput(v **FlattenedXmlMapOutput, decoder smithyxml.NodeDecoder) error { 605 if v == nil { 606 return fmt.Errorf("unexpected nil of type %T", v) 607 } 608 var sv *FlattenedXmlMapOutput 609 if *v == nil { 610 sv = &FlattenedXmlMapOutput{} 611 } else { 612 sv = *v 613 } 614 615 for { 616 t, done, err := decoder.Token() 617 if err != nil { 618 return err 619 } 620 if done { 621 break 622 } 623 originalDecoder := decoder 624 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 625 switch { 626 case strings.EqualFold("myMap", t.Name.Local): 627 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 628 if err := awsRestxml_deserializeDocumentFooEnumMapUnwrapped(&sv.MyMap, nodeDecoder); err != nil { 629 return err 630 } 631 632 default: 633 // Do nothing and ignore the unexpected tag element 634 err = decoder.Decoder.Skip() 635 if err != nil { 636 return err 637 } 638 639 } 640 decoder = originalDecoder 641 } 642 *v = sv 643 return nil 644} 645 646type awsRestxml_deserializeOpFlattenedXmlMapWithXmlName struct { 647} 648 649func (*awsRestxml_deserializeOpFlattenedXmlMapWithXmlName) ID() string { 650 return "OperationDeserializer" 651} 652 653func (m *awsRestxml_deserializeOpFlattenedXmlMapWithXmlName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 654 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 655) { 656 out, metadata, err = next.HandleDeserialize(ctx, in) 657 if err != nil { 658 return out, metadata, err 659 } 660 661 response, ok := out.RawResponse.(*smithyhttp.Response) 662 if !ok { 663 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 664 } 665 666 if response.StatusCode < 200 || response.StatusCode >= 300 { 667 return out, metadata, awsRestxml_deserializeOpErrorFlattenedXmlMapWithXmlName(response, &metadata) 668 } 669 output := &FlattenedXmlMapWithXmlNameOutput{} 670 out.Result = output 671 672 var buff [1024]byte 673 ringBuffer := smithyio.NewRingBuffer(buff[:]) 674 body := io.TeeReader(response.Body, ringBuffer) 675 rootDecoder := xml.NewDecoder(body) 676 t, err := smithyxml.FetchRootElement(rootDecoder) 677 if err == io.EOF { 678 return out, metadata, nil 679 } 680 if err != nil { 681 var snapshot bytes.Buffer 682 io.Copy(&snapshot, ringBuffer) 683 return out, metadata, &smithy.DeserializationError{ 684 Err: fmt.Errorf("failed to decode response body, %w", err), 685 Snapshot: snapshot.Bytes(), 686 } 687 } 688 689 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 690 err = awsRestxml_deserializeOpDocumentFlattenedXmlMapWithXmlNameOutput(&output, decoder) 691 if err != nil { 692 var snapshot bytes.Buffer 693 io.Copy(&snapshot, ringBuffer) 694 return out, metadata, &smithy.DeserializationError{ 695 Err: fmt.Errorf("failed to decode response body, %w", err), 696 Snapshot: snapshot.Bytes(), 697 } 698 } 699 700 return out, metadata, err 701} 702 703func awsRestxml_deserializeOpErrorFlattenedXmlMapWithXmlName(response *smithyhttp.Response, metadata *middleware.Metadata) error { 704 var errorBuffer bytes.Buffer 705 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 706 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 707 } 708 errorBody := bytes.NewReader(errorBuffer.Bytes()) 709 710 errorCode := "UnknownError" 711 errorMessage := errorCode 712 713 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 714 if err != nil { 715 return err 716 } 717 if reqID := errorComponents.RequestID; len(reqID) != 0 { 718 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 719 } 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 738func awsRestxml_deserializeOpDocumentFlattenedXmlMapWithXmlNameOutput(v **FlattenedXmlMapWithXmlNameOutput, decoder smithyxml.NodeDecoder) error { 739 if v == nil { 740 return fmt.Errorf("unexpected nil of type %T", v) 741 } 742 var sv *FlattenedXmlMapWithXmlNameOutput 743 if *v == nil { 744 sv = &FlattenedXmlMapWithXmlNameOutput{} 745 } else { 746 sv = *v 747 } 748 749 for { 750 t, done, err := decoder.Token() 751 if err != nil { 752 return err 753 } 754 if done { 755 break 756 } 757 originalDecoder := decoder 758 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 759 switch { 760 case strings.EqualFold("KVP", t.Name.Local): 761 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 762 if err := awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNameInputOutputMapUnwrapped(&sv.MyMap, nodeDecoder); err != nil { 763 return err 764 } 765 766 default: 767 // Do nothing and ignore the unexpected tag element 768 err = decoder.Decoder.Skip() 769 if err != nil { 770 return err 771 } 772 773 } 774 decoder = originalDecoder 775 } 776 *v = sv 777 return nil 778} 779 780type awsRestxml_deserializeOpFlattenedXmlMapWithXmlNamespace struct { 781} 782 783func (*awsRestxml_deserializeOpFlattenedXmlMapWithXmlNamespace) ID() string { 784 return "OperationDeserializer" 785} 786 787func (m *awsRestxml_deserializeOpFlattenedXmlMapWithXmlNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 788 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 789) { 790 out, metadata, err = next.HandleDeserialize(ctx, in) 791 if err != nil { 792 return out, metadata, err 793 } 794 795 response, ok := out.RawResponse.(*smithyhttp.Response) 796 if !ok { 797 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 798 } 799 800 if response.StatusCode < 200 || response.StatusCode >= 300 { 801 return out, metadata, awsRestxml_deserializeOpErrorFlattenedXmlMapWithXmlNamespace(response, &metadata) 802 } 803 output := &FlattenedXmlMapWithXmlNamespaceOutput{} 804 out.Result = output 805 806 var buff [1024]byte 807 ringBuffer := smithyio.NewRingBuffer(buff[:]) 808 body := io.TeeReader(response.Body, ringBuffer) 809 rootDecoder := xml.NewDecoder(body) 810 t, err := smithyxml.FetchRootElement(rootDecoder) 811 if err == io.EOF { 812 return out, metadata, nil 813 } 814 if err != nil { 815 var snapshot bytes.Buffer 816 io.Copy(&snapshot, ringBuffer) 817 return out, metadata, &smithy.DeserializationError{ 818 Err: fmt.Errorf("failed to decode response body, %w", err), 819 Snapshot: snapshot.Bytes(), 820 } 821 } 822 823 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 824 err = awsRestxml_deserializeOpDocumentFlattenedXmlMapWithXmlNamespaceOutput(&output, decoder) 825 if err != nil { 826 var snapshot bytes.Buffer 827 io.Copy(&snapshot, ringBuffer) 828 return out, metadata, &smithy.DeserializationError{ 829 Err: fmt.Errorf("failed to decode response body, %w", err), 830 Snapshot: snapshot.Bytes(), 831 } 832 } 833 834 return out, metadata, err 835} 836 837func awsRestxml_deserializeOpErrorFlattenedXmlMapWithXmlNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { 838 var errorBuffer bytes.Buffer 839 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 840 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 841 } 842 errorBody := bytes.NewReader(errorBuffer.Bytes()) 843 844 errorCode := "UnknownError" 845 errorMessage := errorCode 846 847 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 848 if err != nil { 849 return err 850 } 851 if reqID := errorComponents.RequestID; len(reqID) != 0 { 852 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 853 } 854 if len(errorComponents.Code) != 0 { 855 errorCode = errorComponents.Code 856 } 857 if len(errorComponents.Message) != 0 { 858 errorMessage = errorComponents.Message 859 } 860 errorBody.Seek(0, io.SeekStart) 861 switch { 862 default: 863 genericError := &smithy.GenericAPIError{ 864 Code: errorCode, 865 Message: errorMessage, 866 } 867 return genericError 868 869 } 870} 871 872func awsRestxml_deserializeOpDocumentFlattenedXmlMapWithXmlNamespaceOutput(v **FlattenedXmlMapWithXmlNamespaceOutput, decoder smithyxml.NodeDecoder) error { 873 if v == nil { 874 return fmt.Errorf("unexpected nil of type %T", v) 875 } 876 var sv *FlattenedXmlMapWithXmlNamespaceOutput 877 if *v == nil { 878 sv = &FlattenedXmlMapWithXmlNamespaceOutput{} 879 } else { 880 sv = *v 881 } 882 883 for { 884 t, done, err := decoder.Token() 885 if err != nil { 886 return err 887 } 888 if done { 889 break 890 } 891 originalDecoder := decoder 892 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 893 switch { 894 case strings.EqualFold("KVP", t.Name.Local): 895 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 896 if err := awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNamespaceOutputMapUnwrapped(&sv.MyMap, nodeDecoder); err != nil { 897 return err 898 } 899 900 default: 901 // Do nothing and ignore the unexpected tag element 902 err = decoder.Decoder.Skip() 903 if err != nil { 904 return err 905 } 906 907 } 908 decoder = originalDecoder 909 } 910 *v = sv 911 return nil 912} 913 914type awsRestxml_deserializeOpGreetingWithErrors struct { 915} 916 917func (*awsRestxml_deserializeOpGreetingWithErrors) ID() string { 918 return "OperationDeserializer" 919} 920 921func (m *awsRestxml_deserializeOpGreetingWithErrors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 922 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 923) { 924 out, metadata, err = next.HandleDeserialize(ctx, in) 925 if err != nil { 926 return out, metadata, err 927 } 928 929 response, ok := out.RawResponse.(*smithyhttp.Response) 930 if !ok { 931 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 932 } 933 934 if response.StatusCode < 200 || response.StatusCode >= 300 { 935 return out, metadata, awsRestxml_deserializeOpErrorGreetingWithErrors(response, &metadata) 936 } 937 output := &GreetingWithErrorsOutput{} 938 out.Result = output 939 940 err = awsRestxml_deserializeOpHttpBindingsGreetingWithErrorsOutput(output, response) 941 if err != nil { 942 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 943 } 944 945 return out, metadata, err 946} 947 948func awsRestxml_deserializeOpErrorGreetingWithErrors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 949 var errorBuffer bytes.Buffer 950 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 951 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 952 } 953 errorBody := bytes.NewReader(errorBuffer.Bytes()) 954 955 errorCode := "UnknownError" 956 errorMessage := errorCode 957 958 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 959 if err != nil { 960 return err 961 } 962 if reqID := errorComponents.RequestID; len(reqID) != 0 { 963 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 964 } 965 if len(errorComponents.Code) != 0 { 966 errorCode = errorComponents.Code 967 } 968 if len(errorComponents.Message) != 0 { 969 errorMessage = errorComponents.Message 970 } 971 errorBody.Seek(0, io.SeekStart) 972 switch { 973 case strings.EqualFold("ComplexError", errorCode): 974 return awsRestxml_deserializeErrorComplexError(response, errorBody) 975 976 case strings.EqualFold("InvalidGreeting", errorCode): 977 return awsRestxml_deserializeErrorInvalidGreeting(response, errorBody) 978 979 default: 980 genericError := &smithy.GenericAPIError{ 981 Code: errorCode, 982 Message: errorMessage, 983 } 984 return genericError 985 986 } 987} 988 989func awsRestxml_deserializeOpHttpBindingsGreetingWithErrorsOutput(v *GreetingWithErrorsOutput, response *smithyhttp.Response) error { 990 if v == nil { 991 return fmt.Errorf("unsupported deserialization for nil %T", v) 992 } 993 994 if headerValues := response.Header.Values("X-Greeting"); len(headerValues) != 0 { 995 headerValues[0] = strings.TrimSpace(headerValues[0]) 996 v.Greeting = ptr.String(headerValues[0]) 997 } 998 999 return nil 1000} 1001 1002type awsRestxml_deserializeOpHttpPayloadTraits struct { 1003} 1004 1005func (*awsRestxml_deserializeOpHttpPayloadTraits) ID() string { 1006 return "OperationDeserializer" 1007} 1008 1009func (m *awsRestxml_deserializeOpHttpPayloadTraits) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1010 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1011) { 1012 out, metadata, err = next.HandleDeserialize(ctx, in) 1013 if err != nil { 1014 return out, metadata, err 1015 } 1016 1017 response, ok := out.RawResponse.(*smithyhttp.Response) 1018 if !ok { 1019 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1020 } 1021 1022 if response.StatusCode < 200 || response.StatusCode >= 300 { 1023 return out, metadata, awsRestxml_deserializeOpErrorHttpPayloadTraits(response, &metadata) 1024 } 1025 output := &HttpPayloadTraitsOutput{} 1026 out.Result = output 1027 1028 err = awsRestxml_deserializeOpHttpBindingsHttpPayloadTraitsOutput(output, response) 1029 if err != nil { 1030 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1031 } 1032 1033 err = awsRestxml_deserializeOpDocumentHttpPayloadTraitsOutput(output, response.Body) 1034 if err != nil { 1035 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 1036 } 1037 1038 return out, metadata, err 1039} 1040 1041func awsRestxml_deserializeOpErrorHttpPayloadTraits(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1042 var errorBuffer bytes.Buffer 1043 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1044 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1045 } 1046 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1047 1048 errorCode := "UnknownError" 1049 errorMessage := errorCode 1050 1051 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1052 if err != nil { 1053 return err 1054 } 1055 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1056 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1057 } 1058 if len(errorComponents.Code) != 0 { 1059 errorCode = errorComponents.Code 1060 } 1061 if len(errorComponents.Message) != 0 { 1062 errorMessage = errorComponents.Message 1063 } 1064 errorBody.Seek(0, io.SeekStart) 1065 switch { 1066 default: 1067 genericError := &smithy.GenericAPIError{ 1068 Code: errorCode, 1069 Message: errorMessage, 1070 } 1071 return genericError 1072 1073 } 1074} 1075 1076func awsRestxml_deserializeOpHttpBindingsHttpPayloadTraitsOutput(v *HttpPayloadTraitsOutput, response *smithyhttp.Response) error { 1077 if v == nil { 1078 return fmt.Errorf("unsupported deserialization for nil %T", v) 1079 } 1080 1081 if headerValues := response.Header.Values("X-Foo"); len(headerValues) != 0 { 1082 headerValues[0] = strings.TrimSpace(headerValues[0]) 1083 v.Foo = ptr.String(headerValues[0]) 1084 } 1085 1086 return nil 1087} 1088func awsRestxml_deserializeOpDocumentHttpPayloadTraitsOutput(v *HttpPayloadTraitsOutput, body io.ReadCloser) error { 1089 if v == nil { 1090 return fmt.Errorf("unsupported deserialization of nil %T", v) 1091 } 1092 bs, err := ioutil.ReadAll(body) 1093 if err != nil { 1094 return err 1095 } 1096 if len(bs) > 0 { 1097 v.Blob = bs 1098 } 1099 return nil 1100} 1101 1102type awsRestxml_deserializeOpHttpPayloadTraitsWithMediaType struct { 1103} 1104 1105func (*awsRestxml_deserializeOpHttpPayloadTraitsWithMediaType) ID() string { 1106 return "OperationDeserializer" 1107} 1108 1109func (m *awsRestxml_deserializeOpHttpPayloadTraitsWithMediaType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1110 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1111) { 1112 out, metadata, err = next.HandleDeserialize(ctx, in) 1113 if err != nil { 1114 return out, metadata, err 1115 } 1116 1117 response, ok := out.RawResponse.(*smithyhttp.Response) 1118 if !ok { 1119 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1120 } 1121 1122 if response.StatusCode < 200 || response.StatusCode >= 300 { 1123 return out, metadata, awsRestxml_deserializeOpErrorHttpPayloadTraitsWithMediaType(response, &metadata) 1124 } 1125 output := &HttpPayloadTraitsWithMediaTypeOutput{} 1126 out.Result = output 1127 1128 err = awsRestxml_deserializeOpHttpBindingsHttpPayloadTraitsWithMediaTypeOutput(output, response) 1129 if err != nil { 1130 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1131 } 1132 1133 err = awsRestxml_deserializeOpDocumentHttpPayloadTraitsWithMediaTypeOutput(output, response.Body) 1134 if err != nil { 1135 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 1136 } 1137 1138 return out, metadata, err 1139} 1140 1141func awsRestxml_deserializeOpErrorHttpPayloadTraitsWithMediaType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1142 var errorBuffer bytes.Buffer 1143 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1144 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1145 } 1146 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1147 1148 errorCode := "UnknownError" 1149 errorMessage := errorCode 1150 1151 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1152 if err != nil { 1153 return err 1154 } 1155 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1156 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1157 } 1158 if len(errorComponents.Code) != 0 { 1159 errorCode = errorComponents.Code 1160 } 1161 if len(errorComponents.Message) != 0 { 1162 errorMessage = errorComponents.Message 1163 } 1164 errorBody.Seek(0, io.SeekStart) 1165 switch { 1166 default: 1167 genericError := &smithy.GenericAPIError{ 1168 Code: errorCode, 1169 Message: errorMessage, 1170 } 1171 return genericError 1172 1173 } 1174} 1175 1176func awsRestxml_deserializeOpHttpBindingsHttpPayloadTraitsWithMediaTypeOutput(v *HttpPayloadTraitsWithMediaTypeOutput, response *smithyhttp.Response) error { 1177 if v == nil { 1178 return fmt.Errorf("unsupported deserialization for nil %T", v) 1179 } 1180 1181 if headerValues := response.Header.Values("X-Foo"); len(headerValues) != 0 { 1182 headerValues[0] = strings.TrimSpace(headerValues[0]) 1183 v.Foo = ptr.String(headerValues[0]) 1184 } 1185 1186 return nil 1187} 1188func awsRestxml_deserializeOpDocumentHttpPayloadTraitsWithMediaTypeOutput(v *HttpPayloadTraitsWithMediaTypeOutput, body io.ReadCloser) error { 1189 if v == nil { 1190 return fmt.Errorf("unsupported deserialization of nil %T", v) 1191 } 1192 bs, err := ioutil.ReadAll(body) 1193 if err != nil { 1194 return err 1195 } 1196 if len(bs) > 0 { 1197 v.Blob = bs 1198 } 1199 return nil 1200} 1201 1202type awsRestxml_deserializeOpHttpPayloadWithStructure struct { 1203} 1204 1205func (*awsRestxml_deserializeOpHttpPayloadWithStructure) ID() string { 1206 return "OperationDeserializer" 1207} 1208 1209func (m *awsRestxml_deserializeOpHttpPayloadWithStructure) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1210 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1211) { 1212 out, metadata, err = next.HandleDeserialize(ctx, in) 1213 if err != nil { 1214 return out, metadata, err 1215 } 1216 1217 response, ok := out.RawResponse.(*smithyhttp.Response) 1218 if !ok { 1219 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1220 } 1221 1222 if response.StatusCode < 200 || response.StatusCode >= 300 { 1223 return out, metadata, awsRestxml_deserializeOpErrorHttpPayloadWithStructure(response, &metadata) 1224 } 1225 output := &HttpPayloadWithStructureOutput{} 1226 out.Result = output 1227 1228 var buff [1024]byte 1229 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1230 body := io.TeeReader(response.Body, ringBuffer) 1231 rootDecoder := xml.NewDecoder(body) 1232 t, err := smithyxml.FetchRootElement(rootDecoder) 1233 if err == io.EOF { 1234 return out, metadata, nil 1235 } 1236 if err != nil { 1237 var snapshot bytes.Buffer 1238 io.Copy(&snapshot, ringBuffer) 1239 return out, metadata, &smithy.DeserializationError{ 1240 Err: fmt.Errorf("failed to decode response body, %w", err), 1241 Snapshot: snapshot.Bytes(), 1242 } 1243 } 1244 1245 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1246 err = awsRestxml_deserializeDocumentNestedPayload(&output.Nested, decoder) 1247 if err != nil { 1248 var snapshot bytes.Buffer 1249 io.Copy(&snapshot, ringBuffer) 1250 return out, metadata, &smithy.DeserializationError{ 1251 Err: fmt.Errorf("failed to decode response body, %w", err), 1252 Snapshot: snapshot.Bytes(), 1253 } 1254 } 1255 1256 return out, metadata, err 1257} 1258 1259func awsRestxml_deserializeOpErrorHttpPayloadWithStructure(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1260 var errorBuffer bytes.Buffer 1261 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1262 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1263 } 1264 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1265 1266 errorCode := "UnknownError" 1267 errorMessage := errorCode 1268 1269 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1270 if err != nil { 1271 return err 1272 } 1273 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1274 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1275 } 1276 if len(errorComponents.Code) != 0 { 1277 errorCode = errorComponents.Code 1278 } 1279 if len(errorComponents.Message) != 0 { 1280 errorMessage = errorComponents.Message 1281 } 1282 errorBody.Seek(0, io.SeekStart) 1283 switch { 1284 default: 1285 genericError := &smithy.GenericAPIError{ 1286 Code: errorCode, 1287 Message: errorMessage, 1288 } 1289 return genericError 1290 1291 } 1292} 1293 1294func awsRestxml_deserializeOpDocumentHttpPayloadWithStructureOutput(v **HttpPayloadWithStructureOutput, decoder smithyxml.NodeDecoder) error { 1295 if v == nil { 1296 return fmt.Errorf("unexpected nil of type %T", v) 1297 } 1298 var sv *HttpPayloadWithStructureOutput 1299 if *v == nil { 1300 sv = &HttpPayloadWithStructureOutput{} 1301 } else { 1302 sv = *v 1303 } 1304 1305 for { 1306 t, done, err := decoder.Token() 1307 if err != nil { 1308 return err 1309 } 1310 if done { 1311 break 1312 } 1313 originalDecoder := decoder 1314 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1315 switch { 1316 case strings.EqualFold("nested", t.Name.Local): 1317 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1318 if err := awsRestxml_deserializeDocumentNestedPayload(&sv.Nested, nodeDecoder); err != nil { 1319 return err 1320 } 1321 1322 default: 1323 // Do nothing and ignore the unexpected tag element 1324 err = decoder.Decoder.Skip() 1325 if err != nil { 1326 return err 1327 } 1328 1329 } 1330 decoder = originalDecoder 1331 } 1332 *v = sv 1333 return nil 1334} 1335 1336type awsRestxml_deserializeOpHttpPayloadWithXmlName struct { 1337} 1338 1339func (*awsRestxml_deserializeOpHttpPayloadWithXmlName) ID() string { 1340 return "OperationDeserializer" 1341} 1342 1343func (m *awsRestxml_deserializeOpHttpPayloadWithXmlName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1344 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1345) { 1346 out, metadata, err = next.HandleDeserialize(ctx, in) 1347 if err != nil { 1348 return out, metadata, err 1349 } 1350 1351 response, ok := out.RawResponse.(*smithyhttp.Response) 1352 if !ok { 1353 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1354 } 1355 1356 if response.StatusCode < 200 || response.StatusCode >= 300 { 1357 return out, metadata, awsRestxml_deserializeOpErrorHttpPayloadWithXmlName(response, &metadata) 1358 } 1359 output := &HttpPayloadWithXmlNameOutput{} 1360 out.Result = output 1361 1362 var buff [1024]byte 1363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1364 body := io.TeeReader(response.Body, ringBuffer) 1365 rootDecoder := xml.NewDecoder(body) 1366 t, err := smithyxml.FetchRootElement(rootDecoder) 1367 if err == io.EOF { 1368 return out, metadata, nil 1369 } 1370 if err != nil { 1371 var snapshot bytes.Buffer 1372 io.Copy(&snapshot, ringBuffer) 1373 return out, metadata, &smithy.DeserializationError{ 1374 Err: fmt.Errorf("failed to decode response body, %w", err), 1375 Snapshot: snapshot.Bytes(), 1376 } 1377 } 1378 1379 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1380 err = awsRestxml_deserializeDocumentPayloadWithXmlName(&output.Nested, decoder) 1381 if err != nil { 1382 var snapshot bytes.Buffer 1383 io.Copy(&snapshot, ringBuffer) 1384 return out, metadata, &smithy.DeserializationError{ 1385 Err: fmt.Errorf("failed to decode response body, %w", err), 1386 Snapshot: snapshot.Bytes(), 1387 } 1388 } 1389 1390 return out, metadata, err 1391} 1392 1393func awsRestxml_deserializeOpErrorHttpPayloadWithXmlName(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1394 var errorBuffer bytes.Buffer 1395 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1396 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1397 } 1398 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1399 1400 errorCode := "UnknownError" 1401 errorMessage := errorCode 1402 1403 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1404 if err != nil { 1405 return err 1406 } 1407 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1408 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1409 } 1410 if len(errorComponents.Code) != 0 { 1411 errorCode = errorComponents.Code 1412 } 1413 if len(errorComponents.Message) != 0 { 1414 errorMessage = errorComponents.Message 1415 } 1416 errorBody.Seek(0, io.SeekStart) 1417 switch { 1418 default: 1419 genericError := &smithy.GenericAPIError{ 1420 Code: errorCode, 1421 Message: errorMessage, 1422 } 1423 return genericError 1424 1425 } 1426} 1427 1428func awsRestxml_deserializeOpDocumentHttpPayloadWithXmlNameOutput(v **HttpPayloadWithXmlNameOutput, decoder smithyxml.NodeDecoder) error { 1429 if v == nil { 1430 return fmt.Errorf("unexpected nil of type %T", v) 1431 } 1432 var sv *HttpPayloadWithXmlNameOutput 1433 if *v == nil { 1434 sv = &HttpPayloadWithXmlNameOutput{} 1435 } else { 1436 sv = *v 1437 } 1438 1439 for { 1440 t, done, err := decoder.Token() 1441 if err != nil { 1442 return err 1443 } 1444 if done { 1445 break 1446 } 1447 originalDecoder := decoder 1448 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1449 switch { 1450 case strings.EqualFold("nested", t.Name.Local): 1451 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1452 if err := awsRestxml_deserializeDocumentPayloadWithXmlName(&sv.Nested, nodeDecoder); err != nil { 1453 return err 1454 } 1455 1456 default: 1457 // Do nothing and ignore the unexpected tag element 1458 err = decoder.Decoder.Skip() 1459 if err != nil { 1460 return err 1461 } 1462 1463 } 1464 decoder = originalDecoder 1465 } 1466 *v = sv 1467 return nil 1468} 1469 1470type awsRestxml_deserializeOpHttpPayloadWithXmlNamespace struct { 1471} 1472 1473func (*awsRestxml_deserializeOpHttpPayloadWithXmlNamespace) ID() string { 1474 return "OperationDeserializer" 1475} 1476 1477func (m *awsRestxml_deserializeOpHttpPayloadWithXmlNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1478 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1479) { 1480 out, metadata, err = next.HandleDeserialize(ctx, in) 1481 if err != nil { 1482 return out, metadata, err 1483 } 1484 1485 response, ok := out.RawResponse.(*smithyhttp.Response) 1486 if !ok { 1487 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1488 } 1489 1490 if response.StatusCode < 200 || response.StatusCode >= 300 { 1491 return out, metadata, awsRestxml_deserializeOpErrorHttpPayloadWithXmlNamespace(response, &metadata) 1492 } 1493 output := &HttpPayloadWithXmlNamespaceOutput{} 1494 out.Result = output 1495 1496 var buff [1024]byte 1497 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1498 body := io.TeeReader(response.Body, ringBuffer) 1499 rootDecoder := xml.NewDecoder(body) 1500 t, err := smithyxml.FetchRootElement(rootDecoder) 1501 if err == io.EOF { 1502 return out, metadata, nil 1503 } 1504 if err != nil { 1505 var snapshot bytes.Buffer 1506 io.Copy(&snapshot, ringBuffer) 1507 return out, metadata, &smithy.DeserializationError{ 1508 Err: fmt.Errorf("failed to decode response body, %w", err), 1509 Snapshot: snapshot.Bytes(), 1510 } 1511 } 1512 1513 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1514 err = awsRestxml_deserializeDocumentPayloadWithXmlNamespace(&output.Nested, decoder) 1515 if err != nil { 1516 var snapshot bytes.Buffer 1517 io.Copy(&snapshot, ringBuffer) 1518 return out, metadata, &smithy.DeserializationError{ 1519 Err: fmt.Errorf("failed to decode response body, %w", err), 1520 Snapshot: snapshot.Bytes(), 1521 } 1522 } 1523 1524 return out, metadata, err 1525} 1526 1527func awsRestxml_deserializeOpErrorHttpPayloadWithXmlNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1528 var errorBuffer bytes.Buffer 1529 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1530 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1531 } 1532 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1533 1534 errorCode := "UnknownError" 1535 errorMessage := errorCode 1536 1537 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1538 if err != nil { 1539 return err 1540 } 1541 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1542 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1543 } 1544 if len(errorComponents.Code) != 0 { 1545 errorCode = errorComponents.Code 1546 } 1547 if len(errorComponents.Message) != 0 { 1548 errorMessage = errorComponents.Message 1549 } 1550 errorBody.Seek(0, io.SeekStart) 1551 switch { 1552 default: 1553 genericError := &smithy.GenericAPIError{ 1554 Code: errorCode, 1555 Message: errorMessage, 1556 } 1557 return genericError 1558 1559 } 1560} 1561 1562func awsRestxml_deserializeOpDocumentHttpPayloadWithXmlNamespaceOutput(v **HttpPayloadWithXmlNamespaceOutput, decoder smithyxml.NodeDecoder) error { 1563 if v == nil { 1564 return fmt.Errorf("unexpected nil of type %T", v) 1565 } 1566 var sv *HttpPayloadWithXmlNamespaceOutput 1567 if *v == nil { 1568 sv = &HttpPayloadWithXmlNamespaceOutput{} 1569 } else { 1570 sv = *v 1571 } 1572 1573 for { 1574 t, done, err := decoder.Token() 1575 if err != nil { 1576 return err 1577 } 1578 if done { 1579 break 1580 } 1581 originalDecoder := decoder 1582 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1583 switch { 1584 case strings.EqualFold("nested", t.Name.Local): 1585 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1586 if err := awsRestxml_deserializeDocumentPayloadWithXmlNamespace(&sv.Nested, nodeDecoder); err != nil { 1587 return err 1588 } 1589 1590 default: 1591 // Do nothing and ignore the unexpected tag element 1592 err = decoder.Decoder.Skip() 1593 if err != nil { 1594 return err 1595 } 1596 1597 } 1598 decoder = originalDecoder 1599 } 1600 *v = sv 1601 return nil 1602} 1603 1604type awsRestxml_deserializeOpHttpPayloadWithXmlNamespaceAndPrefix struct { 1605} 1606 1607func (*awsRestxml_deserializeOpHttpPayloadWithXmlNamespaceAndPrefix) ID() string { 1608 return "OperationDeserializer" 1609} 1610 1611func (m *awsRestxml_deserializeOpHttpPayloadWithXmlNamespaceAndPrefix) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1612 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1613) { 1614 out, metadata, err = next.HandleDeserialize(ctx, in) 1615 if err != nil { 1616 return out, metadata, err 1617 } 1618 1619 response, ok := out.RawResponse.(*smithyhttp.Response) 1620 if !ok { 1621 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1622 } 1623 1624 if response.StatusCode < 200 || response.StatusCode >= 300 { 1625 return out, metadata, awsRestxml_deserializeOpErrorHttpPayloadWithXmlNamespaceAndPrefix(response, &metadata) 1626 } 1627 output := &HttpPayloadWithXmlNamespaceAndPrefixOutput{} 1628 out.Result = output 1629 1630 var buff [1024]byte 1631 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1632 body := io.TeeReader(response.Body, ringBuffer) 1633 rootDecoder := xml.NewDecoder(body) 1634 t, err := smithyxml.FetchRootElement(rootDecoder) 1635 if err == io.EOF { 1636 return out, metadata, nil 1637 } 1638 if err != nil { 1639 var snapshot bytes.Buffer 1640 io.Copy(&snapshot, ringBuffer) 1641 return out, metadata, &smithy.DeserializationError{ 1642 Err: fmt.Errorf("failed to decode response body, %w", err), 1643 Snapshot: snapshot.Bytes(), 1644 } 1645 } 1646 1647 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 1648 err = awsRestxml_deserializeDocumentPayloadWithXmlNamespaceAndPrefix(&output.Nested, decoder) 1649 if err != nil { 1650 var snapshot bytes.Buffer 1651 io.Copy(&snapshot, ringBuffer) 1652 return out, metadata, &smithy.DeserializationError{ 1653 Err: fmt.Errorf("failed to decode response body, %w", err), 1654 Snapshot: snapshot.Bytes(), 1655 } 1656 } 1657 1658 return out, metadata, err 1659} 1660 1661func awsRestxml_deserializeOpErrorHttpPayloadWithXmlNamespaceAndPrefix(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1662 var errorBuffer bytes.Buffer 1663 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1664 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1665 } 1666 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1667 1668 errorCode := "UnknownError" 1669 errorMessage := errorCode 1670 1671 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1672 if err != nil { 1673 return err 1674 } 1675 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1676 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1677 } 1678 if len(errorComponents.Code) != 0 { 1679 errorCode = errorComponents.Code 1680 } 1681 if len(errorComponents.Message) != 0 { 1682 errorMessage = errorComponents.Message 1683 } 1684 errorBody.Seek(0, io.SeekStart) 1685 switch { 1686 default: 1687 genericError := &smithy.GenericAPIError{ 1688 Code: errorCode, 1689 Message: errorMessage, 1690 } 1691 return genericError 1692 1693 } 1694} 1695 1696func awsRestxml_deserializeOpDocumentHttpPayloadWithXmlNamespaceAndPrefixOutput(v **HttpPayloadWithXmlNamespaceAndPrefixOutput, decoder smithyxml.NodeDecoder) error { 1697 if v == nil { 1698 return fmt.Errorf("unexpected nil of type %T", v) 1699 } 1700 var sv *HttpPayloadWithXmlNamespaceAndPrefixOutput 1701 if *v == nil { 1702 sv = &HttpPayloadWithXmlNamespaceAndPrefixOutput{} 1703 } else { 1704 sv = *v 1705 } 1706 1707 for { 1708 t, done, err := decoder.Token() 1709 if err != nil { 1710 return err 1711 } 1712 if done { 1713 break 1714 } 1715 originalDecoder := decoder 1716 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 1717 switch { 1718 case strings.EqualFold("nested", t.Name.Local): 1719 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 1720 if err := awsRestxml_deserializeDocumentPayloadWithXmlNamespaceAndPrefix(&sv.Nested, nodeDecoder); err != nil { 1721 return err 1722 } 1723 1724 default: 1725 // Do nothing and ignore the unexpected tag element 1726 err = decoder.Decoder.Skip() 1727 if err != nil { 1728 return err 1729 } 1730 1731 } 1732 decoder = originalDecoder 1733 } 1734 *v = sv 1735 return nil 1736} 1737 1738type awsRestxml_deserializeOpHttpPrefixHeaders struct { 1739} 1740 1741func (*awsRestxml_deserializeOpHttpPrefixHeaders) ID() string { 1742 return "OperationDeserializer" 1743} 1744 1745func (m *awsRestxml_deserializeOpHttpPrefixHeaders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1746 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1747) { 1748 out, metadata, err = next.HandleDeserialize(ctx, in) 1749 if err != nil { 1750 return out, metadata, err 1751 } 1752 1753 response, ok := out.RawResponse.(*smithyhttp.Response) 1754 if !ok { 1755 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1756 } 1757 1758 if response.StatusCode < 200 || response.StatusCode >= 300 { 1759 return out, metadata, awsRestxml_deserializeOpErrorHttpPrefixHeaders(response, &metadata) 1760 } 1761 output := &HttpPrefixHeadersOutput{} 1762 out.Result = output 1763 1764 err = awsRestxml_deserializeOpHttpBindingsHttpPrefixHeadersOutput(output, response) 1765 if err != nil { 1766 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1767 } 1768 1769 return out, metadata, err 1770} 1771 1772func awsRestxml_deserializeOpErrorHttpPrefixHeaders(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1773 var errorBuffer bytes.Buffer 1774 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1775 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1776 } 1777 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1778 1779 errorCode := "UnknownError" 1780 errorMessage := errorCode 1781 1782 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1783 if err != nil { 1784 return err 1785 } 1786 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1787 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1788 } 1789 if len(errorComponents.Code) != 0 { 1790 errorCode = errorComponents.Code 1791 } 1792 if len(errorComponents.Message) != 0 { 1793 errorMessage = errorComponents.Message 1794 } 1795 errorBody.Seek(0, io.SeekStart) 1796 switch { 1797 default: 1798 genericError := &smithy.GenericAPIError{ 1799 Code: errorCode, 1800 Message: errorMessage, 1801 } 1802 return genericError 1803 1804 } 1805} 1806 1807func awsRestxml_deserializeOpHttpBindingsHttpPrefixHeadersOutput(v *HttpPrefixHeadersOutput, response *smithyhttp.Response) error { 1808 if v == nil { 1809 return fmt.Errorf("unsupported deserialization for nil %T", v) 1810 } 1811 1812 if headerValues := response.Header.Values("X-Foo"); len(headerValues) != 0 { 1813 headerValues[0] = strings.TrimSpace(headerValues[0]) 1814 v.Foo = ptr.String(headerValues[0]) 1815 } 1816 1817 for headerKey, headerValues := range response.Header { 1818 if lenPrefix := len("X-Foo-"); len(headerKey) >= lenPrefix && strings.EqualFold(headerKey[:lenPrefix], "X-Foo-") { 1819 if v.FooMap == nil { 1820 v.FooMap = map[string]string{} 1821 } 1822 headerValues[0] = strings.TrimSpace(headerValues[0]) 1823 v.FooMap[strings.ToLower(headerKey[lenPrefix:])] = headerValues[0] 1824 } 1825 } 1826 1827 return nil 1828} 1829 1830type awsRestxml_deserializeOpHttpRequestWithGreedyLabelInPath struct { 1831} 1832 1833func (*awsRestxml_deserializeOpHttpRequestWithGreedyLabelInPath) ID() string { 1834 return "OperationDeserializer" 1835} 1836 1837func (m *awsRestxml_deserializeOpHttpRequestWithGreedyLabelInPath) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1838 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1839) { 1840 out, metadata, err = next.HandleDeserialize(ctx, in) 1841 if err != nil { 1842 return out, metadata, err 1843 } 1844 1845 response, ok := out.RawResponse.(*smithyhttp.Response) 1846 if !ok { 1847 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1848 } 1849 1850 if response.StatusCode < 200 || response.StatusCode >= 300 { 1851 return out, metadata, awsRestxml_deserializeOpErrorHttpRequestWithGreedyLabelInPath(response, &metadata) 1852 } 1853 output := &HttpRequestWithGreedyLabelInPathOutput{} 1854 out.Result = output 1855 1856 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1857 return out, metadata, &smithy.DeserializationError{ 1858 Err: fmt.Errorf("failed to discard response body, %w", err), 1859 } 1860 } 1861 1862 return out, metadata, err 1863} 1864 1865func awsRestxml_deserializeOpErrorHttpRequestWithGreedyLabelInPath(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1866 var errorBuffer bytes.Buffer 1867 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1868 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1869 } 1870 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1871 1872 errorCode := "UnknownError" 1873 errorMessage := errorCode 1874 1875 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1876 if err != nil { 1877 return err 1878 } 1879 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1880 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1881 } 1882 if len(errorComponents.Code) != 0 { 1883 errorCode = errorComponents.Code 1884 } 1885 if len(errorComponents.Message) != 0 { 1886 errorMessage = errorComponents.Message 1887 } 1888 errorBody.Seek(0, io.SeekStart) 1889 switch { 1890 default: 1891 genericError := &smithy.GenericAPIError{ 1892 Code: errorCode, 1893 Message: errorMessage, 1894 } 1895 return genericError 1896 1897 } 1898} 1899 1900type awsRestxml_deserializeOpHttpRequestWithLabels struct { 1901} 1902 1903func (*awsRestxml_deserializeOpHttpRequestWithLabels) ID() string { 1904 return "OperationDeserializer" 1905} 1906 1907func (m *awsRestxml_deserializeOpHttpRequestWithLabels) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1908 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1909) { 1910 out, metadata, err = next.HandleDeserialize(ctx, in) 1911 if err != nil { 1912 return out, metadata, err 1913 } 1914 1915 response, ok := out.RawResponse.(*smithyhttp.Response) 1916 if !ok { 1917 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1918 } 1919 1920 if response.StatusCode < 200 || response.StatusCode >= 300 { 1921 return out, metadata, awsRestxml_deserializeOpErrorHttpRequestWithLabels(response, &metadata) 1922 } 1923 output := &HttpRequestWithLabelsOutput{} 1924 out.Result = output 1925 1926 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1927 return out, metadata, &smithy.DeserializationError{ 1928 Err: fmt.Errorf("failed to discard response body, %w", err), 1929 } 1930 } 1931 1932 return out, metadata, err 1933} 1934 1935func awsRestxml_deserializeOpErrorHttpRequestWithLabels(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1936 var errorBuffer bytes.Buffer 1937 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1938 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1939 } 1940 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1941 1942 errorCode := "UnknownError" 1943 errorMessage := errorCode 1944 1945 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 1946 if err != nil { 1947 return err 1948 } 1949 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1950 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1951 } 1952 if len(errorComponents.Code) != 0 { 1953 errorCode = errorComponents.Code 1954 } 1955 if len(errorComponents.Message) != 0 { 1956 errorMessage = errorComponents.Message 1957 } 1958 errorBody.Seek(0, io.SeekStart) 1959 switch { 1960 default: 1961 genericError := &smithy.GenericAPIError{ 1962 Code: errorCode, 1963 Message: errorMessage, 1964 } 1965 return genericError 1966 1967 } 1968} 1969 1970type awsRestxml_deserializeOpHttpRequestWithLabelsAndTimestampFormat struct { 1971} 1972 1973func (*awsRestxml_deserializeOpHttpRequestWithLabelsAndTimestampFormat) ID() string { 1974 return "OperationDeserializer" 1975} 1976 1977func (m *awsRestxml_deserializeOpHttpRequestWithLabelsAndTimestampFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1978 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1979) { 1980 out, metadata, err = next.HandleDeserialize(ctx, in) 1981 if err != nil { 1982 return out, metadata, err 1983 } 1984 1985 response, ok := out.RawResponse.(*smithyhttp.Response) 1986 if !ok { 1987 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1988 } 1989 1990 if response.StatusCode < 200 || response.StatusCode >= 300 { 1991 return out, metadata, awsRestxml_deserializeOpErrorHttpRequestWithLabelsAndTimestampFormat(response, &metadata) 1992 } 1993 output := &HttpRequestWithLabelsAndTimestampFormatOutput{} 1994 out.Result = output 1995 1996 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1997 return out, metadata, &smithy.DeserializationError{ 1998 Err: fmt.Errorf("failed to discard response body, %w", err), 1999 } 2000 } 2001 2002 return out, metadata, err 2003} 2004 2005func awsRestxml_deserializeOpErrorHttpRequestWithLabelsAndTimestampFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2006 var errorBuffer bytes.Buffer 2007 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2008 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2009 } 2010 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2011 2012 errorCode := "UnknownError" 2013 errorMessage := errorCode 2014 2015 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2016 if err != nil { 2017 return err 2018 } 2019 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2020 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2021 } 2022 if len(errorComponents.Code) != 0 { 2023 errorCode = errorComponents.Code 2024 } 2025 if len(errorComponents.Message) != 0 { 2026 errorMessage = errorComponents.Message 2027 } 2028 errorBody.Seek(0, io.SeekStart) 2029 switch { 2030 default: 2031 genericError := &smithy.GenericAPIError{ 2032 Code: errorCode, 2033 Message: errorMessage, 2034 } 2035 return genericError 2036 2037 } 2038} 2039 2040type awsRestxml_deserializeOpHttpResponseCode struct { 2041} 2042 2043func (*awsRestxml_deserializeOpHttpResponseCode) ID() string { 2044 return "OperationDeserializer" 2045} 2046 2047func (m *awsRestxml_deserializeOpHttpResponseCode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2048 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2049) { 2050 out, metadata, err = next.HandleDeserialize(ctx, in) 2051 if err != nil { 2052 return out, metadata, err 2053 } 2054 2055 response, ok := out.RawResponse.(*smithyhttp.Response) 2056 if !ok { 2057 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2058 } 2059 2060 if response.StatusCode < 200 || response.StatusCode >= 300 { 2061 return out, metadata, awsRestxml_deserializeOpErrorHttpResponseCode(response, &metadata) 2062 } 2063 output := &HttpResponseCodeOutput{} 2064 out.Result = output 2065 2066 err = awsRestxml_deserializeOpHttpBindingsHttpResponseCodeOutput(output, response) 2067 if err != nil { 2068 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 2069 } 2070 2071 return out, metadata, err 2072} 2073 2074func awsRestxml_deserializeOpErrorHttpResponseCode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2075 var errorBuffer bytes.Buffer 2076 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2077 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2078 } 2079 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2080 2081 errorCode := "UnknownError" 2082 errorMessage := errorCode 2083 2084 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2085 if err != nil { 2086 return err 2087 } 2088 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2089 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2090 } 2091 if len(errorComponents.Code) != 0 { 2092 errorCode = errorComponents.Code 2093 } 2094 if len(errorComponents.Message) != 0 { 2095 errorMessage = errorComponents.Message 2096 } 2097 errorBody.Seek(0, io.SeekStart) 2098 switch { 2099 default: 2100 genericError := &smithy.GenericAPIError{ 2101 Code: errorCode, 2102 Message: errorMessage, 2103 } 2104 return genericError 2105 2106 } 2107} 2108 2109func awsRestxml_deserializeOpHttpBindingsHttpResponseCodeOutput(v *HttpResponseCodeOutput, response *smithyhttp.Response) error { 2110 if v == nil { 2111 return fmt.Errorf("unsupported deserialization for nil %T", v) 2112 } 2113 2114 v.Status = ptr.Int32(int32(response.StatusCode)) 2115 2116 return nil 2117} 2118 2119type awsRestxml_deserializeOpIgnoreQueryParamsInResponse struct { 2120} 2121 2122func (*awsRestxml_deserializeOpIgnoreQueryParamsInResponse) ID() string { 2123 return "OperationDeserializer" 2124} 2125 2126func (m *awsRestxml_deserializeOpIgnoreQueryParamsInResponse) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2127 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2128) { 2129 out, metadata, err = next.HandleDeserialize(ctx, in) 2130 if err != nil { 2131 return out, metadata, err 2132 } 2133 2134 response, ok := out.RawResponse.(*smithyhttp.Response) 2135 if !ok { 2136 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2137 } 2138 2139 if response.StatusCode < 200 || response.StatusCode >= 300 { 2140 return out, metadata, awsRestxml_deserializeOpErrorIgnoreQueryParamsInResponse(response, &metadata) 2141 } 2142 output := &IgnoreQueryParamsInResponseOutput{} 2143 out.Result = output 2144 2145 var buff [1024]byte 2146 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2147 body := io.TeeReader(response.Body, ringBuffer) 2148 rootDecoder := xml.NewDecoder(body) 2149 t, err := smithyxml.FetchRootElement(rootDecoder) 2150 if err == io.EOF { 2151 return out, metadata, nil 2152 } 2153 if err != nil { 2154 var snapshot bytes.Buffer 2155 io.Copy(&snapshot, ringBuffer) 2156 return out, metadata, &smithy.DeserializationError{ 2157 Err: fmt.Errorf("failed to decode response body, %w", err), 2158 Snapshot: snapshot.Bytes(), 2159 } 2160 } 2161 2162 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2163 err = awsRestxml_deserializeOpDocumentIgnoreQueryParamsInResponseOutput(&output, decoder) 2164 if err != nil { 2165 var snapshot bytes.Buffer 2166 io.Copy(&snapshot, ringBuffer) 2167 return out, metadata, &smithy.DeserializationError{ 2168 Err: fmt.Errorf("failed to decode response body, %w", err), 2169 Snapshot: snapshot.Bytes(), 2170 } 2171 } 2172 2173 return out, metadata, err 2174} 2175 2176func awsRestxml_deserializeOpErrorIgnoreQueryParamsInResponse(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2177 var errorBuffer bytes.Buffer 2178 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2179 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2180 } 2181 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2182 2183 errorCode := "UnknownError" 2184 errorMessage := errorCode 2185 2186 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2187 if err != nil { 2188 return err 2189 } 2190 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2191 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2192 } 2193 if len(errorComponents.Code) != 0 { 2194 errorCode = errorComponents.Code 2195 } 2196 if len(errorComponents.Message) != 0 { 2197 errorMessage = errorComponents.Message 2198 } 2199 errorBody.Seek(0, io.SeekStart) 2200 switch { 2201 default: 2202 genericError := &smithy.GenericAPIError{ 2203 Code: errorCode, 2204 Message: errorMessage, 2205 } 2206 return genericError 2207 2208 } 2209} 2210 2211func awsRestxml_deserializeOpDocumentIgnoreQueryParamsInResponseOutput(v **IgnoreQueryParamsInResponseOutput, decoder smithyxml.NodeDecoder) error { 2212 if v == nil { 2213 return fmt.Errorf("unexpected nil of type %T", v) 2214 } 2215 var sv *IgnoreQueryParamsInResponseOutput 2216 if *v == nil { 2217 sv = &IgnoreQueryParamsInResponseOutput{} 2218 } else { 2219 sv = *v 2220 } 2221 2222 for { 2223 t, done, err := decoder.Token() 2224 if err != nil { 2225 return err 2226 } 2227 if done { 2228 break 2229 } 2230 originalDecoder := decoder 2231 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2232 switch { 2233 case strings.EqualFold("baz", t.Name.Local): 2234 val, err := decoder.Value() 2235 if err != nil { 2236 return err 2237 } 2238 if val == nil { 2239 break 2240 } 2241 { 2242 xtv := string(val) 2243 sv.Baz = ptr.String(xtv) 2244 } 2245 2246 default: 2247 // Do nothing and ignore the unexpected tag element 2248 err = decoder.Decoder.Skip() 2249 if err != nil { 2250 return err 2251 } 2252 2253 } 2254 decoder = originalDecoder 2255 } 2256 *v = sv 2257 return nil 2258} 2259 2260type awsRestxml_deserializeOpInputAndOutputWithHeaders struct { 2261} 2262 2263func (*awsRestxml_deserializeOpInputAndOutputWithHeaders) ID() string { 2264 return "OperationDeserializer" 2265} 2266 2267func (m *awsRestxml_deserializeOpInputAndOutputWithHeaders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2268 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2269) { 2270 out, metadata, err = next.HandleDeserialize(ctx, in) 2271 if err != nil { 2272 return out, metadata, err 2273 } 2274 2275 response, ok := out.RawResponse.(*smithyhttp.Response) 2276 if !ok { 2277 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2278 } 2279 2280 if response.StatusCode < 200 || response.StatusCode >= 300 { 2281 return out, metadata, awsRestxml_deserializeOpErrorInputAndOutputWithHeaders(response, &metadata) 2282 } 2283 output := &InputAndOutputWithHeadersOutput{} 2284 out.Result = output 2285 2286 err = awsRestxml_deserializeOpHttpBindingsInputAndOutputWithHeadersOutput(output, response) 2287 if err != nil { 2288 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 2289 } 2290 2291 return out, metadata, err 2292} 2293 2294func awsRestxml_deserializeOpErrorInputAndOutputWithHeaders(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2295 var errorBuffer bytes.Buffer 2296 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2297 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2298 } 2299 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2300 2301 errorCode := "UnknownError" 2302 errorMessage := errorCode 2303 2304 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2305 if err != nil { 2306 return err 2307 } 2308 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2309 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2310 } 2311 if len(errorComponents.Code) != 0 { 2312 errorCode = errorComponents.Code 2313 } 2314 if len(errorComponents.Message) != 0 { 2315 errorMessage = errorComponents.Message 2316 } 2317 errorBody.Seek(0, io.SeekStart) 2318 switch { 2319 default: 2320 genericError := &smithy.GenericAPIError{ 2321 Code: errorCode, 2322 Message: errorMessage, 2323 } 2324 return genericError 2325 2326 } 2327} 2328 2329func awsRestxml_deserializeOpHttpBindingsInputAndOutputWithHeadersOutput(v *InputAndOutputWithHeadersOutput, response *smithyhttp.Response) error { 2330 if v == nil { 2331 return fmt.Errorf("unsupported deserialization for nil %T", v) 2332 } 2333 2334 if headerValues := response.Header.Values("X-BooleanList"); len(headerValues) != 0 { 2335 { 2336 var err error 2337 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2338 if err != nil { 2339 return err 2340 } 2341 } 2342 var list []bool 2343 for _, headerValuesVal := range headerValues { 2344 headerValuesVal = strings.TrimSpace(headerValuesVal) 2345 vv, err := strconv.ParseBool(headerValuesVal) 2346 if err != nil { 2347 return err 2348 } 2349 list = append(list, vv) 2350 } 2351 v.HeaderBooleanList = list 2352 } 2353 2354 if headerValues := response.Header.Values("X-Byte"); len(headerValues) != 0 { 2355 headerValues[0] = strings.TrimSpace(headerValues[0]) 2356 vv, err := strconv.ParseInt(headerValues[0], 0, 8) 2357 if err != nil { 2358 return err 2359 } 2360 v.HeaderByte = ptr.Int8(int8(vv)) 2361 } 2362 2363 if headerValues := response.Header.Values("X-Double"); len(headerValues) != 0 { 2364 headerValues[0] = strings.TrimSpace(headerValues[0]) 2365 vv, err := strconv.ParseFloat(headerValues[0], 64) 2366 if err != nil { 2367 return err 2368 } 2369 v.HeaderDouble = ptr.Float64(vv) 2370 } 2371 2372 if headerValues := response.Header.Values("X-Enum"); len(headerValues) != 0 { 2373 headerValues[0] = strings.TrimSpace(headerValues[0]) 2374 v.HeaderEnum = types.FooEnum(headerValues[0]) 2375 } 2376 2377 if headerValues := response.Header.Values("X-EnumList"); len(headerValues) != 0 { 2378 { 2379 var err error 2380 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2381 if err != nil { 2382 return err 2383 } 2384 } 2385 var list []types.FooEnum 2386 for _, headerValuesVal := range headerValues { 2387 headerValuesVal = strings.TrimSpace(headerValuesVal) 2388 list = append(list, types.FooEnum(headerValuesVal)) 2389 } 2390 v.HeaderEnumList = list 2391 } 2392 2393 if headerValues := response.Header.Values("X-Boolean2"); len(headerValues) != 0 { 2394 headerValues[0] = strings.TrimSpace(headerValues[0]) 2395 vv, err := strconv.ParseBool(headerValues[0]) 2396 if err != nil { 2397 return err 2398 } 2399 v.HeaderFalseBool = ptr.Bool(vv) 2400 } 2401 2402 if headerValues := response.Header.Values("X-Float"); len(headerValues) != 0 { 2403 headerValues[0] = strings.TrimSpace(headerValues[0]) 2404 vv, err := strconv.ParseFloat(headerValues[0], 32) 2405 if err != nil { 2406 return err 2407 } 2408 v.HeaderFloat = ptr.Float32(float32(vv)) 2409 } 2410 2411 if headerValues := response.Header.Values("X-Integer"); len(headerValues) != 0 { 2412 headerValues[0] = strings.TrimSpace(headerValues[0]) 2413 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 2414 if err != nil { 2415 return err 2416 } 2417 v.HeaderInteger = ptr.Int32(int32(vv)) 2418 } 2419 2420 if headerValues := response.Header.Values("X-IntegerList"); len(headerValues) != 0 { 2421 { 2422 var err error 2423 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2424 if err != nil { 2425 return err 2426 } 2427 } 2428 var list []int32 2429 for _, headerValuesVal := range headerValues { 2430 headerValuesVal = strings.TrimSpace(headerValuesVal) 2431 vv, err := strconv.ParseInt(headerValuesVal, 0, 32) 2432 if err != nil { 2433 return err 2434 } 2435 list = append(list, int32(vv)) 2436 } 2437 v.HeaderIntegerList = list 2438 } 2439 2440 if headerValues := response.Header.Values("X-Long"); len(headerValues) != 0 { 2441 headerValues[0] = strings.TrimSpace(headerValues[0]) 2442 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 2443 if err != nil { 2444 return err 2445 } 2446 v.HeaderLong = ptr.Int64(vv) 2447 } 2448 2449 if headerValues := response.Header.Values("X-Short"); len(headerValues) != 0 { 2450 headerValues[0] = strings.TrimSpace(headerValues[0]) 2451 vv, err := strconv.ParseInt(headerValues[0], 0, 16) 2452 if err != nil { 2453 return err 2454 } 2455 v.HeaderShort = ptr.Int16(int16(vv)) 2456 } 2457 2458 if headerValues := response.Header.Values("X-String"); len(headerValues) != 0 { 2459 headerValues[0] = strings.TrimSpace(headerValues[0]) 2460 v.HeaderString = ptr.String(headerValues[0]) 2461 } 2462 2463 if headerValues := response.Header.Values("X-StringList"); len(headerValues) != 0 { 2464 { 2465 var err error 2466 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2467 if err != nil { 2468 return err 2469 } 2470 } 2471 var list []string 2472 for _, headerValuesVal := range headerValues { 2473 headerValuesVal = strings.TrimSpace(headerValuesVal) 2474 list = append(list, headerValuesVal) 2475 } 2476 v.HeaderStringList = list 2477 } 2478 2479 if headerValues := response.Header.Values("X-StringSet"); len(headerValues) != 0 { 2480 { 2481 var err error 2482 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2483 if err != nil { 2484 return err 2485 } 2486 } 2487 var list []string 2488 for _, headerValuesVal := range headerValues { 2489 headerValuesVal = strings.TrimSpace(headerValuesVal) 2490 list = append(list, headerValuesVal) 2491 } 2492 v.HeaderStringSet = list 2493 } 2494 2495 if headerValues := response.Header.Values("X-TimestampList"); len(headerValues) != 0 { 2496 { 2497 var err error 2498 headerValues, err = smithyhttp.SplitHTTPDateTimestampHeaderListValues(headerValues) 2499 if err != nil { 2500 return err 2501 } 2502 } 2503 var list []time.Time 2504 for _, headerValuesVal := range headerValues { 2505 headerValuesVal = strings.TrimSpace(headerValuesVal) 2506 t, err := smithytime.ParseHTTPDate(headerValuesVal) 2507 if err != nil { 2508 return err 2509 } 2510 list = append(list, t) 2511 } 2512 v.HeaderTimestampList = list 2513 } 2514 2515 if headerValues := response.Header.Values("X-Boolean1"); len(headerValues) != 0 { 2516 headerValues[0] = strings.TrimSpace(headerValues[0]) 2517 vv, err := strconv.ParseBool(headerValues[0]) 2518 if err != nil { 2519 return err 2520 } 2521 v.HeaderTrueBool = ptr.Bool(vv) 2522 } 2523 2524 return nil 2525} 2526 2527type awsRestxml_deserializeOpNoInputAndNoOutput struct { 2528} 2529 2530func (*awsRestxml_deserializeOpNoInputAndNoOutput) ID() string { 2531 return "OperationDeserializer" 2532} 2533 2534func (m *awsRestxml_deserializeOpNoInputAndNoOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2535 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2536) { 2537 out, metadata, err = next.HandleDeserialize(ctx, in) 2538 if err != nil { 2539 return out, metadata, err 2540 } 2541 2542 response, ok := out.RawResponse.(*smithyhttp.Response) 2543 if !ok { 2544 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2545 } 2546 2547 if response.StatusCode < 200 || response.StatusCode >= 300 { 2548 return out, metadata, awsRestxml_deserializeOpErrorNoInputAndNoOutput(response, &metadata) 2549 } 2550 output := &NoInputAndNoOutputOutput{} 2551 out.Result = output 2552 2553 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2554 return out, metadata, &smithy.DeserializationError{ 2555 Err: fmt.Errorf("failed to discard response body, %w", err), 2556 } 2557 } 2558 2559 return out, metadata, err 2560} 2561 2562func awsRestxml_deserializeOpErrorNoInputAndNoOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2563 var errorBuffer bytes.Buffer 2564 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2565 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2566 } 2567 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2568 2569 errorCode := "UnknownError" 2570 errorMessage := errorCode 2571 2572 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2573 if err != nil { 2574 return err 2575 } 2576 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2577 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2578 } 2579 if len(errorComponents.Code) != 0 { 2580 errorCode = errorComponents.Code 2581 } 2582 if len(errorComponents.Message) != 0 { 2583 errorMessage = errorComponents.Message 2584 } 2585 errorBody.Seek(0, io.SeekStart) 2586 switch { 2587 default: 2588 genericError := &smithy.GenericAPIError{ 2589 Code: errorCode, 2590 Message: errorMessage, 2591 } 2592 return genericError 2593 2594 } 2595} 2596 2597type awsRestxml_deserializeOpNoInputAndOutput struct { 2598} 2599 2600func (*awsRestxml_deserializeOpNoInputAndOutput) ID() string { 2601 return "OperationDeserializer" 2602} 2603 2604func (m *awsRestxml_deserializeOpNoInputAndOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2605 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2606) { 2607 out, metadata, err = next.HandleDeserialize(ctx, in) 2608 if err != nil { 2609 return out, metadata, err 2610 } 2611 2612 response, ok := out.RawResponse.(*smithyhttp.Response) 2613 if !ok { 2614 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2615 } 2616 2617 if response.StatusCode < 200 || response.StatusCode >= 300 { 2618 return out, metadata, awsRestxml_deserializeOpErrorNoInputAndOutput(response, &metadata) 2619 } 2620 output := &NoInputAndOutputOutput{} 2621 out.Result = output 2622 2623 return out, metadata, err 2624} 2625 2626func awsRestxml_deserializeOpErrorNoInputAndOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2627 var errorBuffer bytes.Buffer 2628 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2629 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2630 } 2631 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2632 2633 errorCode := "UnknownError" 2634 errorMessage := errorCode 2635 2636 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2637 if err != nil { 2638 return err 2639 } 2640 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2641 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2642 } 2643 if len(errorComponents.Code) != 0 { 2644 errorCode = errorComponents.Code 2645 } 2646 if len(errorComponents.Message) != 0 { 2647 errorMessage = errorComponents.Message 2648 } 2649 errorBody.Seek(0, io.SeekStart) 2650 switch { 2651 default: 2652 genericError := &smithy.GenericAPIError{ 2653 Code: errorCode, 2654 Message: errorMessage, 2655 } 2656 return genericError 2657 2658 } 2659} 2660 2661type awsRestxml_deserializeOpNullAndEmptyHeadersClient struct { 2662} 2663 2664func (*awsRestxml_deserializeOpNullAndEmptyHeadersClient) ID() string { 2665 return "OperationDeserializer" 2666} 2667 2668func (m *awsRestxml_deserializeOpNullAndEmptyHeadersClient) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2669 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2670) { 2671 out, metadata, err = next.HandleDeserialize(ctx, in) 2672 if err != nil { 2673 return out, metadata, err 2674 } 2675 2676 response, ok := out.RawResponse.(*smithyhttp.Response) 2677 if !ok { 2678 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2679 } 2680 2681 if response.StatusCode < 200 || response.StatusCode >= 300 { 2682 return out, metadata, awsRestxml_deserializeOpErrorNullAndEmptyHeadersClient(response, &metadata) 2683 } 2684 output := &NullAndEmptyHeadersClientOutput{} 2685 out.Result = output 2686 2687 err = awsRestxml_deserializeOpHttpBindingsNullAndEmptyHeadersClientOutput(output, response) 2688 if err != nil { 2689 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 2690 } 2691 2692 return out, metadata, err 2693} 2694 2695func awsRestxml_deserializeOpErrorNullAndEmptyHeadersClient(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2696 var errorBuffer bytes.Buffer 2697 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2698 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2699 } 2700 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2701 2702 errorCode := "UnknownError" 2703 errorMessage := errorCode 2704 2705 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2706 if err != nil { 2707 return err 2708 } 2709 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2710 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2711 } 2712 if len(errorComponents.Code) != 0 { 2713 errorCode = errorComponents.Code 2714 } 2715 if len(errorComponents.Message) != 0 { 2716 errorMessage = errorComponents.Message 2717 } 2718 errorBody.Seek(0, io.SeekStart) 2719 switch { 2720 default: 2721 genericError := &smithy.GenericAPIError{ 2722 Code: errorCode, 2723 Message: errorMessage, 2724 } 2725 return genericError 2726 2727 } 2728} 2729 2730func awsRestxml_deserializeOpHttpBindingsNullAndEmptyHeadersClientOutput(v *NullAndEmptyHeadersClientOutput, response *smithyhttp.Response) error { 2731 if v == nil { 2732 return fmt.Errorf("unsupported deserialization for nil %T", v) 2733 } 2734 2735 if headerValues := response.Header.Values("X-A"); len(headerValues) != 0 { 2736 headerValues[0] = strings.TrimSpace(headerValues[0]) 2737 v.A = ptr.String(headerValues[0]) 2738 } 2739 2740 if headerValues := response.Header.Values("X-B"); len(headerValues) != 0 { 2741 headerValues[0] = strings.TrimSpace(headerValues[0]) 2742 v.B = ptr.String(headerValues[0]) 2743 } 2744 2745 if headerValues := response.Header.Values("X-C"); len(headerValues) != 0 { 2746 { 2747 var err error 2748 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2749 if err != nil { 2750 return err 2751 } 2752 } 2753 var list []string 2754 for _, headerValuesVal := range headerValues { 2755 headerValuesVal = strings.TrimSpace(headerValuesVal) 2756 list = append(list, headerValuesVal) 2757 } 2758 v.C = list 2759 } 2760 2761 return nil 2762} 2763 2764type awsRestxml_deserializeOpNullAndEmptyHeadersServer struct { 2765} 2766 2767func (*awsRestxml_deserializeOpNullAndEmptyHeadersServer) ID() string { 2768 return "OperationDeserializer" 2769} 2770 2771func (m *awsRestxml_deserializeOpNullAndEmptyHeadersServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2772 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2773) { 2774 out, metadata, err = next.HandleDeserialize(ctx, in) 2775 if err != nil { 2776 return out, metadata, err 2777 } 2778 2779 response, ok := out.RawResponse.(*smithyhttp.Response) 2780 if !ok { 2781 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2782 } 2783 2784 if response.StatusCode < 200 || response.StatusCode >= 300 { 2785 return out, metadata, awsRestxml_deserializeOpErrorNullAndEmptyHeadersServer(response, &metadata) 2786 } 2787 output := &NullAndEmptyHeadersServerOutput{} 2788 out.Result = output 2789 2790 err = awsRestxml_deserializeOpHttpBindingsNullAndEmptyHeadersServerOutput(output, response) 2791 if err != nil { 2792 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 2793 } 2794 2795 return out, metadata, err 2796} 2797 2798func awsRestxml_deserializeOpErrorNullAndEmptyHeadersServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2799 var errorBuffer bytes.Buffer 2800 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2801 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2802 } 2803 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2804 2805 errorCode := "UnknownError" 2806 errorMessage := errorCode 2807 2808 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2809 if err != nil { 2810 return err 2811 } 2812 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2813 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2814 } 2815 if len(errorComponents.Code) != 0 { 2816 errorCode = errorComponents.Code 2817 } 2818 if len(errorComponents.Message) != 0 { 2819 errorMessage = errorComponents.Message 2820 } 2821 errorBody.Seek(0, io.SeekStart) 2822 switch { 2823 default: 2824 genericError := &smithy.GenericAPIError{ 2825 Code: errorCode, 2826 Message: errorMessage, 2827 } 2828 return genericError 2829 2830 } 2831} 2832 2833func awsRestxml_deserializeOpHttpBindingsNullAndEmptyHeadersServerOutput(v *NullAndEmptyHeadersServerOutput, response *smithyhttp.Response) error { 2834 if v == nil { 2835 return fmt.Errorf("unsupported deserialization for nil %T", v) 2836 } 2837 2838 if headerValues := response.Header.Values("X-A"); len(headerValues) != 0 { 2839 headerValues[0] = strings.TrimSpace(headerValues[0]) 2840 v.A = ptr.String(headerValues[0]) 2841 } 2842 2843 if headerValues := response.Header.Values("X-B"); len(headerValues) != 0 { 2844 headerValues[0] = strings.TrimSpace(headerValues[0]) 2845 v.B = ptr.String(headerValues[0]) 2846 } 2847 2848 if headerValues := response.Header.Values("X-C"); len(headerValues) != 0 { 2849 { 2850 var err error 2851 headerValues, err = smithyhttp.SplitHeaderListValues(headerValues) 2852 if err != nil { 2853 return err 2854 } 2855 } 2856 var list []string 2857 for _, headerValuesVal := range headerValues { 2858 headerValuesVal = strings.TrimSpace(headerValuesVal) 2859 list = append(list, headerValuesVal) 2860 } 2861 v.C = list 2862 } 2863 2864 return nil 2865} 2866 2867type awsRestxml_deserializeOpOmitsNullSerializesEmptyString struct { 2868} 2869 2870func (*awsRestxml_deserializeOpOmitsNullSerializesEmptyString) ID() string { 2871 return "OperationDeserializer" 2872} 2873 2874func (m *awsRestxml_deserializeOpOmitsNullSerializesEmptyString) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2875 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2876) { 2877 out, metadata, err = next.HandleDeserialize(ctx, in) 2878 if err != nil { 2879 return out, metadata, err 2880 } 2881 2882 response, ok := out.RawResponse.(*smithyhttp.Response) 2883 if !ok { 2884 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2885 } 2886 2887 if response.StatusCode < 200 || response.StatusCode >= 300 { 2888 return out, metadata, awsRestxml_deserializeOpErrorOmitsNullSerializesEmptyString(response, &metadata) 2889 } 2890 output := &OmitsNullSerializesEmptyStringOutput{} 2891 out.Result = output 2892 2893 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2894 return out, metadata, &smithy.DeserializationError{ 2895 Err: fmt.Errorf("failed to discard response body, %w", err), 2896 } 2897 } 2898 2899 return out, metadata, err 2900} 2901 2902func awsRestxml_deserializeOpErrorOmitsNullSerializesEmptyString(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2903 var errorBuffer bytes.Buffer 2904 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2905 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2906 } 2907 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2908 2909 errorCode := "UnknownError" 2910 errorMessage := errorCode 2911 2912 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2913 if err != nil { 2914 return err 2915 } 2916 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2917 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2918 } 2919 if len(errorComponents.Code) != 0 { 2920 errorCode = errorComponents.Code 2921 } 2922 if len(errorComponents.Message) != 0 { 2923 errorMessage = errorComponents.Message 2924 } 2925 errorBody.Seek(0, io.SeekStart) 2926 switch { 2927 default: 2928 genericError := &smithy.GenericAPIError{ 2929 Code: errorCode, 2930 Message: errorMessage, 2931 } 2932 return genericError 2933 2934 } 2935} 2936 2937type awsRestxml_deserializeOpQueryIdempotencyTokenAutoFill struct { 2938} 2939 2940func (*awsRestxml_deserializeOpQueryIdempotencyTokenAutoFill) ID() string { 2941 return "OperationDeserializer" 2942} 2943 2944func (m *awsRestxml_deserializeOpQueryIdempotencyTokenAutoFill) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2945 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2946) { 2947 out, metadata, err = next.HandleDeserialize(ctx, in) 2948 if err != nil { 2949 return out, metadata, err 2950 } 2951 2952 response, ok := out.RawResponse.(*smithyhttp.Response) 2953 if !ok { 2954 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2955 } 2956 2957 if response.StatusCode < 200 || response.StatusCode >= 300 { 2958 return out, metadata, awsRestxml_deserializeOpErrorQueryIdempotencyTokenAutoFill(response, &metadata) 2959 } 2960 output := &QueryIdempotencyTokenAutoFillOutput{} 2961 out.Result = output 2962 2963 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2964 return out, metadata, &smithy.DeserializationError{ 2965 Err: fmt.Errorf("failed to discard response body, %w", err), 2966 } 2967 } 2968 2969 return out, metadata, err 2970} 2971 2972func awsRestxml_deserializeOpErrorQueryIdempotencyTokenAutoFill(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2973 var errorBuffer bytes.Buffer 2974 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2975 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2976 } 2977 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2978 2979 errorCode := "UnknownError" 2980 errorMessage := errorCode 2981 2982 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 2983 if err != nil { 2984 return err 2985 } 2986 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2987 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2988 } 2989 if len(errorComponents.Code) != 0 { 2990 errorCode = errorComponents.Code 2991 } 2992 if len(errorComponents.Message) != 0 { 2993 errorMessage = errorComponents.Message 2994 } 2995 errorBody.Seek(0, io.SeekStart) 2996 switch { 2997 default: 2998 genericError := &smithy.GenericAPIError{ 2999 Code: errorCode, 3000 Message: errorMessage, 3001 } 3002 return genericError 3003 3004 } 3005} 3006 3007type awsRestxml_deserializeOpRecursiveShapes struct { 3008} 3009 3010func (*awsRestxml_deserializeOpRecursiveShapes) ID() string { 3011 return "OperationDeserializer" 3012} 3013 3014func (m *awsRestxml_deserializeOpRecursiveShapes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3015 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3016) { 3017 out, metadata, err = next.HandleDeserialize(ctx, in) 3018 if err != nil { 3019 return out, metadata, err 3020 } 3021 3022 response, ok := out.RawResponse.(*smithyhttp.Response) 3023 if !ok { 3024 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3025 } 3026 3027 if response.StatusCode < 200 || response.StatusCode >= 300 { 3028 return out, metadata, awsRestxml_deserializeOpErrorRecursiveShapes(response, &metadata) 3029 } 3030 output := &RecursiveShapesOutput{} 3031 out.Result = output 3032 3033 var buff [1024]byte 3034 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3035 body := io.TeeReader(response.Body, ringBuffer) 3036 rootDecoder := xml.NewDecoder(body) 3037 t, err := smithyxml.FetchRootElement(rootDecoder) 3038 if err == io.EOF { 3039 return out, metadata, nil 3040 } 3041 if err != nil { 3042 var snapshot bytes.Buffer 3043 io.Copy(&snapshot, ringBuffer) 3044 return out, metadata, &smithy.DeserializationError{ 3045 Err: fmt.Errorf("failed to decode response body, %w", err), 3046 Snapshot: snapshot.Bytes(), 3047 } 3048 } 3049 3050 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3051 err = awsRestxml_deserializeOpDocumentRecursiveShapesOutput(&output, decoder) 3052 if err != nil { 3053 var snapshot bytes.Buffer 3054 io.Copy(&snapshot, ringBuffer) 3055 return out, metadata, &smithy.DeserializationError{ 3056 Err: fmt.Errorf("failed to decode response body, %w", err), 3057 Snapshot: snapshot.Bytes(), 3058 } 3059 } 3060 3061 return out, metadata, err 3062} 3063 3064func awsRestxml_deserializeOpErrorRecursiveShapes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3065 var errorBuffer bytes.Buffer 3066 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3067 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3068 } 3069 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3070 3071 errorCode := "UnknownError" 3072 errorMessage := errorCode 3073 3074 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3075 if err != nil { 3076 return err 3077 } 3078 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3079 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3080 } 3081 if len(errorComponents.Code) != 0 { 3082 errorCode = errorComponents.Code 3083 } 3084 if len(errorComponents.Message) != 0 { 3085 errorMessage = errorComponents.Message 3086 } 3087 errorBody.Seek(0, io.SeekStart) 3088 switch { 3089 default: 3090 genericError := &smithy.GenericAPIError{ 3091 Code: errorCode, 3092 Message: errorMessage, 3093 } 3094 return genericError 3095 3096 } 3097} 3098 3099func awsRestxml_deserializeOpDocumentRecursiveShapesOutput(v **RecursiveShapesOutput, decoder smithyxml.NodeDecoder) error { 3100 if v == nil { 3101 return fmt.Errorf("unexpected nil of type %T", v) 3102 } 3103 var sv *RecursiveShapesOutput 3104 if *v == nil { 3105 sv = &RecursiveShapesOutput{} 3106 } else { 3107 sv = *v 3108 } 3109 3110 for { 3111 t, done, err := decoder.Token() 3112 if err != nil { 3113 return err 3114 } 3115 if done { 3116 break 3117 } 3118 originalDecoder := decoder 3119 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3120 switch { 3121 case strings.EqualFold("nested", t.Name.Local): 3122 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3123 if err := awsRestxml_deserializeDocumentRecursiveShapesInputOutputNested1(&sv.Nested, nodeDecoder); err != nil { 3124 return err 3125 } 3126 3127 default: 3128 // Do nothing and ignore the unexpected tag element 3129 err = decoder.Decoder.Skip() 3130 if err != nil { 3131 return err 3132 } 3133 3134 } 3135 decoder = originalDecoder 3136 } 3137 *v = sv 3138 return nil 3139} 3140 3141type awsRestxml_deserializeOpSimpleScalarProperties struct { 3142} 3143 3144func (*awsRestxml_deserializeOpSimpleScalarProperties) ID() string { 3145 return "OperationDeserializer" 3146} 3147 3148func (m *awsRestxml_deserializeOpSimpleScalarProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3150) { 3151 out, metadata, err = next.HandleDeserialize(ctx, in) 3152 if err != nil { 3153 return out, metadata, err 3154 } 3155 3156 response, ok := out.RawResponse.(*smithyhttp.Response) 3157 if !ok { 3158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3159 } 3160 3161 if response.StatusCode < 200 || response.StatusCode >= 300 { 3162 return out, metadata, awsRestxml_deserializeOpErrorSimpleScalarProperties(response, &metadata) 3163 } 3164 output := &SimpleScalarPropertiesOutput{} 3165 out.Result = output 3166 3167 err = awsRestxml_deserializeOpHttpBindingsSimpleScalarPropertiesOutput(output, response) 3168 if err != nil { 3169 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 3170 } 3171 3172 var buff [1024]byte 3173 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3174 body := io.TeeReader(response.Body, ringBuffer) 3175 rootDecoder := xml.NewDecoder(body) 3176 t, err := smithyxml.FetchRootElement(rootDecoder) 3177 if err == io.EOF { 3178 return out, metadata, nil 3179 } 3180 if err != nil { 3181 var snapshot bytes.Buffer 3182 io.Copy(&snapshot, ringBuffer) 3183 return out, metadata, &smithy.DeserializationError{ 3184 Err: fmt.Errorf("failed to decode response body, %w", err), 3185 Snapshot: snapshot.Bytes(), 3186 } 3187 } 3188 3189 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3190 err = awsRestxml_deserializeOpDocumentSimpleScalarPropertiesOutput(&output, decoder) 3191 if err != nil { 3192 var snapshot bytes.Buffer 3193 io.Copy(&snapshot, ringBuffer) 3194 return out, metadata, &smithy.DeserializationError{ 3195 Err: fmt.Errorf("failed to decode response body, %w", err), 3196 Snapshot: snapshot.Bytes(), 3197 } 3198 } 3199 3200 return out, metadata, err 3201} 3202 3203func awsRestxml_deserializeOpErrorSimpleScalarProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3204 var errorBuffer bytes.Buffer 3205 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3206 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3207 } 3208 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3209 3210 errorCode := "UnknownError" 3211 errorMessage := errorCode 3212 3213 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3214 if err != nil { 3215 return err 3216 } 3217 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3218 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3219 } 3220 if len(errorComponents.Code) != 0 { 3221 errorCode = errorComponents.Code 3222 } 3223 if len(errorComponents.Message) != 0 { 3224 errorMessage = errorComponents.Message 3225 } 3226 errorBody.Seek(0, io.SeekStart) 3227 switch { 3228 default: 3229 genericError := &smithy.GenericAPIError{ 3230 Code: errorCode, 3231 Message: errorMessage, 3232 } 3233 return genericError 3234 3235 } 3236} 3237 3238func awsRestxml_deserializeOpHttpBindingsSimpleScalarPropertiesOutput(v *SimpleScalarPropertiesOutput, response *smithyhttp.Response) error { 3239 if v == nil { 3240 return fmt.Errorf("unsupported deserialization for nil %T", v) 3241 } 3242 3243 if headerValues := response.Header.Values("X-Foo"); len(headerValues) != 0 { 3244 headerValues[0] = strings.TrimSpace(headerValues[0]) 3245 v.Foo = ptr.String(headerValues[0]) 3246 } 3247 3248 return nil 3249} 3250func awsRestxml_deserializeOpDocumentSimpleScalarPropertiesOutput(v **SimpleScalarPropertiesOutput, decoder smithyxml.NodeDecoder) error { 3251 if v == nil { 3252 return fmt.Errorf("unexpected nil of type %T", v) 3253 } 3254 var sv *SimpleScalarPropertiesOutput 3255 if *v == nil { 3256 sv = &SimpleScalarPropertiesOutput{} 3257 } else { 3258 sv = *v 3259 } 3260 3261 for { 3262 t, done, err := decoder.Token() 3263 if err != nil { 3264 return err 3265 } 3266 if done { 3267 break 3268 } 3269 originalDecoder := decoder 3270 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3271 switch { 3272 case strings.EqualFold("byteValue", t.Name.Local): 3273 val, err := decoder.Value() 3274 if err != nil { 3275 return err 3276 } 3277 if val == nil { 3278 break 3279 } 3280 { 3281 xtv := string(val) 3282 i64, err := strconv.ParseInt(xtv, 10, 64) 3283 if err != nil { 3284 return err 3285 } 3286 sv.ByteValue = ptr.Int8(int8(i64)) 3287 } 3288 3289 case strings.EqualFold("DoubleDribble", t.Name.Local): 3290 val, err := decoder.Value() 3291 if err != nil { 3292 return err 3293 } 3294 if val == nil { 3295 break 3296 } 3297 { 3298 xtv := string(val) 3299 f64, err := strconv.ParseFloat(xtv, 64) 3300 if err != nil { 3301 return err 3302 } 3303 sv.DoubleValue = ptr.Float64(f64) 3304 } 3305 3306 case strings.EqualFold("falseBooleanValue", t.Name.Local): 3307 val, err := decoder.Value() 3308 if err != nil { 3309 return err 3310 } 3311 if val == nil { 3312 break 3313 } 3314 { 3315 xtv, err := strconv.ParseBool(string(val)) 3316 if err != nil { 3317 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 3318 } 3319 sv.FalseBooleanValue = ptr.Bool(xtv) 3320 } 3321 3322 case strings.EqualFold("floatValue", t.Name.Local): 3323 val, err := decoder.Value() 3324 if err != nil { 3325 return err 3326 } 3327 if val == nil { 3328 break 3329 } 3330 { 3331 xtv := string(val) 3332 f64, err := strconv.ParseFloat(xtv, 64) 3333 if err != nil { 3334 return err 3335 } 3336 sv.FloatValue = ptr.Float32(float32(f64)) 3337 } 3338 3339 case strings.EqualFold("integerValue", t.Name.Local): 3340 val, err := decoder.Value() 3341 if err != nil { 3342 return err 3343 } 3344 if val == nil { 3345 break 3346 } 3347 { 3348 xtv := string(val) 3349 i64, err := strconv.ParseInt(xtv, 10, 64) 3350 if err != nil { 3351 return err 3352 } 3353 sv.IntegerValue = ptr.Int32(int32(i64)) 3354 } 3355 3356 case strings.EqualFold("longValue", t.Name.Local): 3357 val, err := decoder.Value() 3358 if err != nil { 3359 return err 3360 } 3361 if val == nil { 3362 break 3363 } 3364 { 3365 xtv := string(val) 3366 i64, err := strconv.ParseInt(xtv, 10, 64) 3367 if err != nil { 3368 return err 3369 } 3370 sv.LongValue = ptr.Int64(i64) 3371 } 3372 3373 case strings.EqualFold("shortValue", 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 i64, err := strconv.ParseInt(xtv, 10, 64) 3384 if err != nil { 3385 return err 3386 } 3387 sv.ShortValue = ptr.Int16(int16(i64)) 3388 } 3389 3390 case strings.EqualFold("stringValue", t.Name.Local): 3391 val, err := decoder.Value() 3392 if err != nil { 3393 return err 3394 } 3395 if val == nil { 3396 break 3397 } 3398 { 3399 xtv := string(val) 3400 sv.StringValue = ptr.String(xtv) 3401 } 3402 3403 case strings.EqualFold("trueBooleanValue", t.Name.Local): 3404 val, err := decoder.Value() 3405 if err != nil { 3406 return err 3407 } 3408 if val == nil { 3409 break 3410 } 3411 { 3412 xtv, err := strconv.ParseBool(string(val)) 3413 if err != nil { 3414 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 3415 } 3416 sv.TrueBooleanValue = ptr.Bool(xtv) 3417 } 3418 3419 default: 3420 // Do nothing and ignore the unexpected tag element 3421 err = decoder.Decoder.Skip() 3422 if err != nil { 3423 return err 3424 } 3425 3426 } 3427 decoder = originalDecoder 3428 } 3429 *v = sv 3430 return nil 3431} 3432 3433type awsRestxml_deserializeOpTimestampFormatHeaders struct { 3434} 3435 3436func (*awsRestxml_deserializeOpTimestampFormatHeaders) ID() string { 3437 return "OperationDeserializer" 3438} 3439 3440func (m *awsRestxml_deserializeOpTimestampFormatHeaders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3441 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3442) { 3443 out, metadata, err = next.HandleDeserialize(ctx, in) 3444 if err != nil { 3445 return out, metadata, err 3446 } 3447 3448 response, ok := out.RawResponse.(*smithyhttp.Response) 3449 if !ok { 3450 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3451 } 3452 3453 if response.StatusCode < 200 || response.StatusCode >= 300 { 3454 return out, metadata, awsRestxml_deserializeOpErrorTimestampFormatHeaders(response, &metadata) 3455 } 3456 output := &TimestampFormatHeadersOutput{} 3457 out.Result = output 3458 3459 err = awsRestxml_deserializeOpHttpBindingsTimestampFormatHeadersOutput(output, response) 3460 if err != nil { 3461 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 3462 } 3463 3464 return out, metadata, err 3465} 3466 3467func awsRestxml_deserializeOpErrorTimestampFormatHeaders(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3468 var errorBuffer bytes.Buffer 3469 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3470 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3471 } 3472 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3473 3474 errorCode := "UnknownError" 3475 errorMessage := errorCode 3476 3477 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3478 if err != nil { 3479 return err 3480 } 3481 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3482 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3483 } 3484 if len(errorComponents.Code) != 0 { 3485 errorCode = errorComponents.Code 3486 } 3487 if len(errorComponents.Message) != 0 { 3488 errorMessage = errorComponents.Message 3489 } 3490 errorBody.Seek(0, io.SeekStart) 3491 switch { 3492 default: 3493 genericError := &smithy.GenericAPIError{ 3494 Code: errorCode, 3495 Message: errorMessage, 3496 } 3497 return genericError 3498 3499 } 3500} 3501 3502func awsRestxml_deserializeOpHttpBindingsTimestampFormatHeadersOutput(v *TimestampFormatHeadersOutput, response *smithyhttp.Response) error { 3503 if v == nil { 3504 return fmt.Errorf("unsupported deserialization for nil %T", v) 3505 } 3506 3507 if headerValues := response.Header.Values("X-defaultFormat"); len(headerValues) != 0 { 3508 headerValues[0] = strings.TrimSpace(headerValues[0]) 3509 t, err := smithytime.ParseHTTPDate(headerValues[0]) 3510 if err != nil { 3511 return err 3512 } 3513 v.DefaultFormat = ptr.Time(t) 3514 } 3515 3516 if headerValues := response.Header.Values("X-memberDateTime"); len(headerValues) != 0 { 3517 headerValues[0] = strings.TrimSpace(headerValues[0]) 3518 t, err := smithytime.ParseDateTime(headerValues[0]) 3519 if err != nil { 3520 return err 3521 } 3522 v.MemberDateTime = ptr.Time(t) 3523 } 3524 3525 if headerValues := response.Header.Values("X-memberEpochSeconds"); len(headerValues) != 0 { 3526 headerValues[0] = strings.TrimSpace(headerValues[0]) 3527 f, err := strconv.ParseFloat(headerValues[0], 64) 3528 if err != nil { 3529 return err 3530 } 3531 t := smithytime.ParseEpochSeconds(f) 3532 v.MemberEpochSeconds = ptr.Time(t) 3533 } 3534 3535 if headerValues := response.Header.Values("X-memberHttpDate"); len(headerValues) != 0 { 3536 headerValues[0] = strings.TrimSpace(headerValues[0]) 3537 t, err := smithytime.ParseHTTPDate(headerValues[0]) 3538 if err != nil { 3539 return err 3540 } 3541 v.MemberHttpDate = ptr.Time(t) 3542 } 3543 3544 if headerValues := response.Header.Values("X-targetDateTime"); len(headerValues) != 0 { 3545 headerValues[0] = strings.TrimSpace(headerValues[0]) 3546 t, err := smithytime.ParseDateTime(headerValues[0]) 3547 if err != nil { 3548 return err 3549 } 3550 v.TargetDateTime = ptr.Time(t) 3551 } 3552 3553 if headerValues := response.Header.Values("X-targetEpochSeconds"); len(headerValues) != 0 { 3554 headerValues[0] = strings.TrimSpace(headerValues[0]) 3555 f, err := strconv.ParseFloat(headerValues[0], 64) 3556 if err != nil { 3557 return err 3558 } 3559 t := smithytime.ParseEpochSeconds(f) 3560 v.TargetEpochSeconds = ptr.Time(t) 3561 } 3562 3563 if headerValues := response.Header.Values("X-targetHttpDate"); len(headerValues) != 0 { 3564 headerValues[0] = strings.TrimSpace(headerValues[0]) 3565 t, err := smithytime.ParseHTTPDate(headerValues[0]) 3566 if err != nil { 3567 return err 3568 } 3569 v.TargetHttpDate = ptr.Time(t) 3570 } 3571 3572 return nil 3573} 3574 3575type awsRestxml_deserializeOpXmlAttributes struct { 3576} 3577 3578func (*awsRestxml_deserializeOpXmlAttributes) ID() string { 3579 return "OperationDeserializer" 3580} 3581 3582func (m *awsRestxml_deserializeOpXmlAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3583 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3584) { 3585 out, metadata, err = next.HandleDeserialize(ctx, in) 3586 if err != nil { 3587 return out, metadata, err 3588 } 3589 3590 response, ok := out.RawResponse.(*smithyhttp.Response) 3591 if !ok { 3592 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3593 } 3594 3595 if response.StatusCode < 200 || response.StatusCode >= 300 { 3596 return out, metadata, awsRestxml_deserializeOpErrorXmlAttributes(response, &metadata) 3597 } 3598 output := &XmlAttributesOutput{} 3599 out.Result = output 3600 3601 var buff [1024]byte 3602 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3603 body := io.TeeReader(response.Body, ringBuffer) 3604 rootDecoder := xml.NewDecoder(body) 3605 t, err := smithyxml.FetchRootElement(rootDecoder) 3606 if err == io.EOF { 3607 return out, metadata, nil 3608 } 3609 if err != nil { 3610 var snapshot bytes.Buffer 3611 io.Copy(&snapshot, ringBuffer) 3612 return out, metadata, &smithy.DeserializationError{ 3613 Err: fmt.Errorf("failed to decode response body, %w", err), 3614 Snapshot: snapshot.Bytes(), 3615 } 3616 } 3617 3618 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3619 err = awsRestxml_deserializeOpDocumentXmlAttributesOutput(&output, decoder) 3620 if err != nil { 3621 var snapshot bytes.Buffer 3622 io.Copy(&snapshot, ringBuffer) 3623 return out, metadata, &smithy.DeserializationError{ 3624 Err: fmt.Errorf("failed to decode response body, %w", err), 3625 Snapshot: snapshot.Bytes(), 3626 } 3627 } 3628 3629 return out, metadata, err 3630} 3631 3632func awsRestxml_deserializeOpErrorXmlAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3633 var errorBuffer bytes.Buffer 3634 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3635 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3636 } 3637 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3638 3639 errorCode := "UnknownError" 3640 errorMessage := errorCode 3641 3642 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3643 if err != nil { 3644 return err 3645 } 3646 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3647 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3648 } 3649 if len(errorComponents.Code) != 0 { 3650 errorCode = errorComponents.Code 3651 } 3652 if len(errorComponents.Message) != 0 { 3653 errorMessage = errorComponents.Message 3654 } 3655 errorBody.Seek(0, io.SeekStart) 3656 switch { 3657 default: 3658 genericError := &smithy.GenericAPIError{ 3659 Code: errorCode, 3660 Message: errorMessage, 3661 } 3662 return genericError 3663 3664 } 3665} 3666 3667func awsRestxml_deserializeOpDocumentXmlAttributesOutput(v **XmlAttributesOutput, decoder smithyxml.NodeDecoder) error { 3668 if v == nil { 3669 return fmt.Errorf("unexpected nil of type %T", v) 3670 } 3671 var sv *XmlAttributesOutput 3672 if *v == nil { 3673 sv = &XmlAttributesOutput{} 3674 } else { 3675 sv = *v 3676 } 3677 3678 for _, attr := range decoder.StartEl.Attr { 3679 name := attr.Name.Local 3680 if len(attr.Name.Space) != 0 { 3681 name = attr.Name.Space + `:` + attr.Name.Local 3682 } 3683 switch { 3684 case strings.EqualFold("test", name): 3685 val := []byte(attr.Value) 3686 { 3687 xtv := string(val) 3688 sv.Attr = ptr.String(xtv) 3689 } 3690 3691 } 3692 } 3693 for { 3694 t, done, err := decoder.Token() 3695 if err != nil { 3696 return err 3697 } 3698 if done { 3699 break 3700 } 3701 originalDecoder := decoder 3702 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3703 switch { 3704 case strings.EqualFold("foo", t.Name.Local): 3705 val, err := decoder.Value() 3706 if err != nil { 3707 return err 3708 } 3709 if val == nil { 3710 break 3711 } 3712 { 3713 xtv := string(val) 3714 sv.Foo = ptr.String(xtv) 3715 } 3716 3717 default: 3718 // Do nothing and ignore the unexpected tag element 3719 err = decoder.Decoder.Skip() 3720 if err != nil { 3721 return err 3722 } 3723 3724 } 3725 decoder = originalDecoder 3726 } 3727 *v = sv 3728 return nil 3729} 3730 3731type awsRestxml_deserializeOpXmlAttributesOnPayload struct { 3732} 3733 3734func (*awsRestxml_deserializeOpXmlAttributesOnPayload) ID() string { 3735 return "OperationDeserializer" 3736} 3737 3738func (m *awsRestxml_deserializeOpXmlAttributesOnPayload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3739 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3740) { 3741 out, metadata, err = next.HandleDeserialize(ctx, in) 3742 if err != nil { 3743 return out, metadata, err 3744 } 3745 3746 response, ok := out.RawResponse.(*smithyhttp.Response) 3747 if !ok { 3748 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3749 } 3750 3751 if response.StatusCode < 200 || response.StatusCode >= 300 { 3752 return out, metadata, awsRestxml_deserializeOpErrorXmlAttributesOnPayload(response, &metadata) 3753 } 3754 output := &XmlAttributesOnPayloadOutput{} 3755 out.Result = output 3756 3757 var buff [1024]byte 3758 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3759 body := io.TeeReader(response.Body, ringBuffer) 3760 rootDecoder := xml.NewDecoder(body) 3761 t, err := smithyxml.FetchRootElement(rootDecoder) 3762 if err == io.EOF { 3763 return out, metadata, nil 3764 } 3765 if err != nil { 3766 var snapshot bytes.Buffer 3767 io.Copy(&snapshot, ringBuffer) 3768 return out, metadata, &smithy.DeserializationError{ 3769 Err: fmt.Errorf("failed to decode response body, %w", err), 3770 Snapshot: snapshot.Bytes(), 3771 } 3772 } 3773 3774 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3775 err = awsRestxml_deserializeDocumentXmlAttributesInputOutput(&output.Payload, decoder) 3776 if err != nil { 3777 var snapshot bytes.Buffer 3778 io.Copy(&snapshot, ringBuffer) 3779 return out, metadata, &smithy.DeserializationError{ 3780 Err: fmt.Errorf("failed to decode response body, %w", err), 3781 Snapshot: snapshot.Bytes(), 3782 } 3783 } 3784 3785 return out, metadata, err 3786} 3787 3788func awsRestxml_deserializeOpErrorXmlAttributesOnPayload(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3789 var errorBuffer bytes.Buffer 3790 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3791 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3792 } 3793 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3794 3795 errorCode := "UnknownError" 3796 errorMessage := errorCode 3797 3798 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3799 if err != nil { 3800 return err 3801 } 3802 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3803 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3804 } 3805 if len(errorComponents.Code) != 0 { 3806 errorCode = errorComponents.Code 3807 } 3808 if len(errorComponents.Message) != 0 { 3809 errorMessage = errorComponents.Message 3810 } 3811 errorBody.Seek(0, io.SeekStart) 3812 switch { 3813 default: 3814 genericError := &smithy.GenericAPIError{ 3815 Code: errorCode, 3816 Message: errorMessage, 3817 } 3818 return genericError 3819 3820 } 3821} 3822 3823func awsRestxml_deserializeOpDocumentXmlAttributesOnPayloadOutput(v **XmlAttributesOnPayloadOutput, decoder smithyxml.NodeDecoder) error { 3824 if v == nil { 3825 return fmt.Errorf("unexpected nil of type %T", v) 3826 } 3827 var sv *XmlAttributesOnPayloadOutput 3828 if *v == nil { 3829 sv = &XmlAttributesOnPayloadOutput{} 3830 } else { 3831 sv = *v 3832 } 3833 3834 for { 3835 t, done, err := decoder.Token() 3836 if err != nil { 3837 return err 3838 } 3839 if done { 3840 break 3841 } 3842 originalDecoder := decoder 3843 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3844 switch { 3845 case strings.EqualFold("payload", t.Name.Local): 3846 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3847 if err := awsRestxml_deserializeDocumentXmlAttributesInputOutput(&sv.Payload, nodeDecoder); err != nil { 3848 return err 3849 } 3850 3851 default: 3852 // Do nothing and ignore the unexpected tag element 3853 err = decoder.Decoder.Skip() 3854 if err != nil { 3855 return err 3856 } 3857 3858 } 3859 decoder = originalDecoder 3860 } 3861 *v = sv 3862 return nil 3863} 3864 3865type awsRestxml_deserializeOpXmlBlobs struct { 3866} 3867 3868func (*awsRestxml_deserializeOpXmlBlobs) ID() string { 3869 return "OperationDeserializer" 3870} 3871 3872func (m *awsRestxml_deserializeOpXmlBlobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3873 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3874) { 3875 out, metadata, err = next.HandleDeserialize(ctx, in) 3876 if err != nil { 3877 return out, metadata, err 3878 } 3879 3880 response, ok := out.RawResponse.(*smithyhttp.Response) 3881 if !ok { 3882 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3883 } 3884 3885 if response.StatusCode < 200 || response.StatusCode >= 300 { 3886 return out, metadata, awsRestxml_deserializeOpErrorXmlBlobs(response, &metadata) 3887 } 3888 output := &XmlBlobsOutput{} 3889 out.Result = output 3890 3891 var buff [1024]byte 3892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3893 body := io.TeeReader(response.Body, ringBuffer) 3894 rootDecoder := xml.NewDecoder(body) 3895 t, err := smithyxml.FetchRootElement(rootDecoder) 3896 if err == io.EOF { 3897 return out, metadata, nil 3898 } 3899 if err != nil { 3900 var snapshot bytes.Buffer 3901 io.Copy(&snapshot, ringBuffer) 3902 return out, metadata, &smithy.DeserializationError{ 3903 Err: fmt.Errorf("failed to decode response body, %w", err), 3904 Snapshot: snapshot.Bytes(), 3905 } 3906 } 3907 3908 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3909 err = awsRestxml_deserializeOpDocumentXmlBlobsOutput(&output, decoder) 3910 if err != nil { 3911 var snapshot bytes.Buffer 3912 io.Copy(&snapshot, ringBuffer) 3913 return out, metadata, &smithy.DeserializationError{ 3914 Err: fmt.Errorf("failed to decode response body, %w", err), 3915 Snapshot: snapshot.Bytes(), 3916 } 3917 } 3918 3919 return out, metadata, err 3920} 3921 3922func awsRestxml_deserializeOpErrorXmlBlobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3923 var errorBuffer bytes.Buffer 3924 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3925 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3926 } 3927 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3928 3929 errorCode := "UnknownError" 3930 errorMessage := errorCode 3931 3932 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 3933 if err != nil { 3934 return err 3935 } 3936 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3937 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3938 } 3939 if len(errorComponents.Code) != 0 { 3940 errorCode = errorComponents.Code 3941 } 3942 if len(errorComponents.Message) != 0 { 3943 errorMessage = errorComponents.Message 3944 } 3945 errorBody.Seek(0, io.SeekStart) 3946 switch { 3947 default: 3948 genericError := &smithy.GenericAPIError{ 3949 Code: errorCode, 3950 Message: errorMessage, 3951 } 3952 return genericError 3953 3954 } 3955} 3956 3957func awsRestxml_deserializeOpDocumentXmlBlobsOutput(v **XmlBlobsOutput, decoder smithyxml.NodeDecoder) error { 3958 if v == nil { 3959 return fmt.Errorf("unexpected nil of type %T", v) 3960 } 3961 var sv *XmlBlobsOutput 3962 if *v == nil { 3963 sv = &XmlBlobsOutput{} 3964 } else { 3965 sv = *v 3966 } 3967 3968 for { 3969 t, done, err := decoder.Token() 3970 if err != nil { 3971 return err 3972 } 3973 if done { 3974 break 3975 } 3976 originalDecoder := decoder 3977 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3978 switch { 3979 case strings.EqualFold("data", t.Name.Local): 3980 var data string 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 data = xtv 3991 } 3992 sv.Data, err = base64.StdEncoding.DecodeString(data) 3993 if err != nil { 3994 return err 3995 } 3996 3997 default: 3998 // Do nothing and ignore the unexpected tag element 3999 err = decoder.Decoder.Skip() 4000 if err != nil { 4001 return err 4002 } 4003 4004 } 4005 decoder = originalDecoder 4006 } 4007 *v = sv 4008 return nil 4009} 4010 4011type awsRestxml_deserializeOpXmlEmptyBlobs struct { 4012} 4013 4014func (*awsRestxml_deserializeOpXmlEmptyBlobs) ID() string { 4015 return "OperationDeserializer" 4016} 4017 4018func (m *awsRestxml_deserializeOpXmlEmptyBlobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4019 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4020) { 4021 out, metadata, err = next.HandleDeserialize(ctx, in) 4022 if err != nil { 4023 return out, metadata, err 4024 } 4025 4026 response, ok := out.RawResponse.(*smithyhttp.Response) 4027 if !ok { 4028 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4029 } 4030 4031 if response.StatusCode < 200 || response.StatusCode >= 300 { 4032 return out, metadata, awsRestxml_deserializeOpErrorXmlEmptyBlobs(response, &metadata) 4033 } 4034 output := &XmlEmptyBlobsOutput{} 4035 out.Result = output 4036 4037 var buff [1024]byte 4038 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4039 body := io.TeeReader(response.Body, ringBuffer) 4040 rootDecoder := xml.NewDecoder(body) 4041 t, err := smithyxml.FetchRootElement(rootDecoder) 4042 if err == io.EOF { 4043 return out, metadata, nil 4044 } 4045 if err != nil { 4046 var snapshot bytes.Buffer 4047 io.Copy(&snapshot, ringBuffer) 4048 return out, metadata, &smithy.DeserializationError{ 4049 Err: fmt.Errorf("failed to decode response body, %w", err), 4050 Snapshot: snapshot.Bytes(), 4051 } 4052 } 4053 4054 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4055 err = awsRestxml_deserializeOpDocumentXmlEmptyBlobsOutput(&output, decoder) 4056 if err != nil { 4057 var snapshot bytes.Buffer 4058 io.Copy(&snapshot, ringBuffer) 4059 return out, metadata, &smithy.DeserializationError{ 4060 Err: fmt.Errorf("failed to decode response body, %w", err), 4061 Snapshot: snapshot.Bytes(), 4062 } 4063 } 4064 4065 return out, metadata, err 4066} 4067 4068func awsRestxml_deserializeOpErrorXmlEmptyBlobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4069 var errorBuffer bytes.Buffer 4070 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4071 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4072 } 4073 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4074 4075 errorCode := "UnknownError" 4076 errorMessage := errorCode 4077 4078 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4079 if err != nil { 4080 return err 4081 } 4082 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4083 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4084 } 4085 if len(errorComponents.Code) != 0 { 4086 errorCode = errorComponents.Code 4087 } 4088 if len(errorComponents.Message) != 0 { 4089 errorMessage = errorComponents.Message 4090 } 4091 errorBody.Seek(0, io.SeekStart) 4092 switch { 4093 default: 4094 genericError := &smithy.GenericAPIError{ 4095 Code: errorCode, 4096 Message: errorMessage, 4097 } 4098 return genericError 4099 4100 } 4101} 4102 4103func awsRestxml_deserializeOpDocumentXmlEmptyBlobsOutput(v **XmlEmptyBlobsOutput, decoder smithyxml.NodeDecoder) error { 4104 if v == nil { 4105 return fmt.Errorf("unexpected nil of type %T", v) 4106 } 4107 var sv *XmlEmptyBlobsOutput 4108 if *v == nil { 4109 sv = &XmlEmptyBlobsOutput{} 4110 } else { 4111 sv = *v 4112 } 4113 4114 for { 4115 t, done, err := decoder.Token() 4116 if err != nil { 4117 return err 4118 } 4119 if done { 4120 break 4121 } 4122 originalDecoder := decoder 4123 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4124 switch { 4125 case strings.EqualFold("data", t.Name.Local): 4126 var data string 4127 val, err := decoder.Value() 4128 if err != nil { 4129 return err 4130 } 4131 if val == nil { 4132 break 4133 } 4134 { 4135 xtv := string(val) 4136 data = xtv 4137 } 4138 sv.Data, err = base64.StdEncoding.DecodeString(data) 4139 if err != nil { 4140 return err 4141 } 4142 4143 default: 4144 // Do nothing and ignore the unexpected tag element 4145 err = decoder.Decoder.Skip() 4146 if err != nil { 4147 return err 4148 } 4149 4150 } 4151 decoder = originalDecoder 4152 } 4153 *v = sv 4154 return nil 4155} 4156 4157type awsRestxml_deserializeOpXmlEmptyLists struct { 4158} 4159 4160func (*awsRestxml_deserializeOpXmlEmptyLists) ID() string { 4161 return "OperationDeserializer" 4162} 4163 4164func (m *awsRestxml_deserializeOpXmlEmptyLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4165 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4166) { 4167 out, metadata, err = next.HandleDeserialize(ctx, in) 4168 if err != nil { 4169 return out, metadata, err 4170 } 4171 4172 response, ok := out.RawResponse.(*smithyhttp.Response) 4173 if !ok { 4174 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4175 } 4176 4177 if response.StatusCode < 200 || response.StatusCode >= 300 { 4178 return out, metadata, awsRestxml_deserializeOpErrorXmlEmptyLists(response, &metadata) 4179 } 4180 output := &XmlEmptyListsOutput{} 4181 out.Result = output 4182 4183 var buff [1024]byte 4184 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4185 body := io.TeeReader(response.Body, ringBuffer) 4186 rootDecoder := xml.NewDecoder(body) 4187 t, err := smithyxml.FetchRootElement(rootDecoder) 4188 if err == io.EOF { 4189 return out, metadata, nil 4190 } 4191 if err != nil { 4192 var snapshot bytes.Buffer 4193 io.Copy(&snapshot, ringBuffer) 4194 return out, metadata, &smithy.DeserializationError{ 4195 Err: fmt.Errorf("failed to decode response body, %w", err), 4196 Snapshot: snapshot.Bytes(), 4197 } 4198 } 4199 4200 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4201 err = awsRestxml_deserializeOpDocumentXmlEmptyListsOutput(&output, decoder) 4202 if err != nil { 4203 var snapshot bytes.Buffer 4204 io.Copy(&snapshot, ringBuffer) 4205 return out, metadata, &smithy.DeserializationError{ 4206 Err: fmt.Errorf("failed to decode response body, %w", err), 4207 Snapshot: snapshot.Bytes(), 4208 } 4209 } 4210 4211 return out, metadata, err 4212} 4213 4214func awsRestxml_deserializeOpErrorXmlEmptyLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4215 var errorBuffer bytes.Buffer 4216 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4217 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4218 } 4219 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4220 4221 errorCode := "UnknownError" 4222 errorMessage := errorCode 4223 4224 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4225 if err != nil { 4226 return err 4227 } 4228 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4229 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4230 } 4231 if len(errorComponents.Code) != 0 { 4232 errorCode = errorComponents.Code 4233 } 4234 if len(errorComponents.Message) != 0 { 4235 errorMessage = errorComponents.Message 4236 } 4237 errorBody.Seek(0, io.SeekStart) 4238 switch { 4239 default: 4240 genericError := &smithy.GenericAPIError{ 4241 Code: errorCode, 4242 Message: errorMessage, 4243 } 4244 return genericError 4245 4246 } 4247} 4248 4249func awsRestxml_deserializeOpDocumentXmlEmptyListsOutput(v **XmlEmptyListsOutput, decoder smithyxml.NodeDecoder) error { 4250 if v == nil { 4251 return fmt.Errorf("unexpected nil of type %T", v) 4252 } 4253 var sv *XmlEmptyListsOutput 4254 if *v == nil { 4255 sv = &XmlEmptyListsOutput{} 4256 } else { 4257 sv = *v 4258 } 4259 4260 for { 4261 t, done, err := decoder.Token() 4262 if err != nil { 4263 return err 4264 } 4265 if done { 4266 break 4267 } 4268 originalDecoder := decoder 4269 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4270 switch { 4271 case strings.EqualFold("booleanList", t.Name.Local): 4272 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4273 if err := awsRestxml_deserializeDocumentBooleanList(&sv.BooleanList, nodeDecoder); err != nil { 4274 return err 4275 } 4276 4277 case strings.EqualFold("enumList", t.Name.Local): 4278 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4279 if err := awsRestxml_deserializeDocumentFooEnumList(&sv.EnumList, nodeDecoder); err != nil { 4280 return err 4281 } 4282 4283 case strings.EqualFold("flattenedList", t.Name.Local): 4284 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4285 if err := awsRestxml_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList, nodeDecoder); err != nil { 4286 return err 4287 } 4288 4289 case strings.EqualFold("customName", t.Name.Local): 4290 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4291 if err := awsRestxml_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList2, nodeDecoder); err != nil { 4292 return err 4293 } 4294 4295 case strings.EqualFold("flattenedListWithMemberNamespace", t.Name.Local): 4296 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4297 if err := awsRestxml_deserializeDocumentListWithMemberNamespaceUnwrapped(&sv.FlattenedListWithMemberNamespace, nodeDecoder); err != nil { 4298 return err 4299 } 4300 4301 case strings.EqualFold("flattenedListWithNamespace", t.Name.Local): 4302 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4303 if err := awsRestxml_deserializeDocumentListWithNamespaceUnwrapped(&sv.FlattenedListWithNamespace, nodeDecoder); err != nil { 4304 return err 4305 } 4306 4307 case strings.EqualFold("integerList", t.Name.Local): 4308 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4309 if err := awsRestxml_deserializeDocumentIntegerList(&sv.IntegerList, nodeDecoder); err != nil { 4310 return err 4311 } 4312 4313 case strings.EqualFold("nestedStringList", t.Name.Local): 4314 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4315 if err := awsRestxml_deserializeDocumentNestedStringList(&sv.NestedStringList, nodeDecoder); err != nil { 4316 return err 4317 } 4318 4319 case strings.EqualFold("renamed", t.Name.Local): 4320 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4321 if err := awsRestxml_deserializeDocumentRenamedListMembers(&sv.RenamedListMembers, nodeDecoder); err != nil { 4322 return err 4323 } 4324 4325 case strings.EqualFold("stringList", t.Name.Local): 4326 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4327 if err := awsRestxml_deserializeDocumentStringList(&sv.StringList, nodeDecoder); err != nil { 4328 return err 4329 } 4330 4331 case strings.EqualFold("stringSet", t.Name.Local): 4332 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4333 if err := awsRestxml_deserializeDocumentStringSet(&sv.StringSet, nodeDecoder); err != nil { 4334 return err 4335 } 4336 4337 case strings.EqualFold("myStructureList", t.Name.Local): 4338 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4339 if err := awsRestxml_deserializeDocumentStructureList(&sv.StructureList, nodeDecoder); err != nil { 4340 return err 4341 } 4342 4343 case strings.EqualFold("timestampList", t.Name.Local): 4344 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4345 if err := awsRestxml_deserializeDocumentTimestampList(&sv.TimestampList, nodeDecoder); err != nil { 4346 return err 4347 } 4348 4349 default: 4350 // Do nothing and ignore the unexpected tag element 4351 err = decoder.Decoder.Skip() 4352 if err != nil { 4353 return err 4354 } 4355 4356 } 4357 decoder = originalDecoder 4358 } 4359 *v = sv 4360 return nil 4361} 4362 4363type awsRestxml_deserializeOpXmlEmptyMaps struct { 4364} 4365 4366func (*awsRestxml_deserializeOpXmlEmptyMaps) ID() string { 4367 return "OperationDeserializer" 4368} 4369 4370func (m *awsRestxml_deserializeOpXmlEmptyMaps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4371 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4372) { 4373 out, metadata, err = next.HandleDeserialize(ctx, in) 4374 if err != nil { 4375 return out, metadata, err 4376 } 4377 4378 response, ok := out.RawResponse.(*smithyhttp.Response) 4379 if !ok { 4380 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4381 } 4382 4383 if response.StatusCode < 200 || response.StatusCode >= 300 { 4384 return out, metadata, awsRestxml_deserializeOpErrorXmlEmptyMaps(response, &metadata) 4385 } 4386 output := &XmlEmptyMapsOutput{} 4387 out.Result = output 4388 4389 var buff [1024]byte 4390 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4391 body := io.TeeReader(response.Body, ringBuffer) 4392 rootDecoder := xml.NewDecoder(body) 4393 t, err := smithyxml.FetchRootElement(rootDecoder) 4394 if err == io.EOF { 4395 return out, metadata, nil 4396 } 4397 if err != nil { 4398 var snapshot bytes.Buffer 4399 io.Copy(&snapshot, ringBuffer) 4400 return out, metadata, &smithy.DeserializationError{ 4401 Err: fmt.Errorf("failed to decode response body, %w", err), 4402 Snapshot: snapshot.Bytes(), 4403 } 4404 } 4405 4406 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4407 err = awsRestxml_deserializeOpDocumentXmlEmptyMapsOutput(&output, decoder) 4408 if err != nil { 4409 var snapshot bytes.Buffer 4410 io.Copy(&snapshot, ringBuffer) 4411 return out, metadata, &smithy.DeserializationError{ 4412 Err: fmt.Errorf("failed to decode response body, %w", err), 4413 Snapshot: snapshot.Bytes(), 4414 } 4415 } 4416 4417 return out, metadata, err 4418} 4419 4420func awsRestxml_deserializeOpErrorXmlEmptyMaps(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4421 var errorBuffer bytes.Buffer 4422 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4423 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4424 } 4425 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4426 4427 errorCode := "UnknownError" 4428 errorMessage := errorCode 4429 4430 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4431 if err != nil { 4432 return err 4433 } 4434 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4435 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4436 } 4437 if len(errorComponents.Code) != 0 { 4438 errorCode = errorComponents.Code 4439 } 4440 if len(errorComponents.Message) != 0 { 4441 errorMessage = errorComponents.Message 4442 } 4443 errorBody.Seek(0, io.SeekStart) 4444 switch { 4445 default: 4446 genericError := &smithy.GenericAPIError{ 4447 Code: errorCode, 4448 Message: errorMessage, 4449 } 4450 return genericError 4451 4452 } 4453} 4454 4455func awsRestxml_deserializeOpDocumentXmlEmptyMapsOutput(v **XmlEmptyMapsOutput, decoder smithyxml.NodeDecoder) error { 4456 if v == nil { 4457 return fmt.Errorf("unexpected nil of type %T", v) 4458 } 4459 var sv *XmlEmptyMapsOutput 4460 if *v == nil { 4461 sv = &XmlEmptyMapsOutput{} 4462 } else { 4463 sv = *v 4464 } 4465 4466 for { 4467 t, done, err := decoder.Token() 4468 if err != nil { 4469 return err 4470 } 4471 if done { 4472 break 4473 } 4474 originalDecoder := decoder 4475 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4476 switch { 4477 case strings.EqualFold("myMap", t.Name.Local): 4478 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4479 if err := awsRestxml_deserializeDocumentXmlMapsInputOutputMap(&sv.MyMap, nodeDecoder); err != nil { 4480 return err 4481 } 4482 4483 default: 4484 // Do nothing and ignore the unexpected tag element 4485 err = decoder.Decoder.Skip() 4486 if err != nil { 4487 return err 4488 } 4489 4490 } 4491 decoder = originalDecoder 4492 } 4493 *v = sv 4494 return nil 4495} 4496 4497type awsRestxml_deserializeOpXmlEmptyStrings struct { 4498} 4499 4500func (*awsRestxml_deserializeOpXmlEmptyStrings) ID() string { 4501 return "OperationDeserializer" 4502} 4503 4504func (m *awsRestxml_deserializeOpXmlEmptyStrings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4505 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4506) { 4507 out, metadata, err = next.HandleDeserialize(ctx, in) 4508 if err != nil { 4509 return out, metadata, err 4510 } 4511 4512 response, ok := out.RawResponse.(*smithyhttp.Response) 4513 if !ok { 4514 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4515 } 4516 4517 if response.StatusCode < 200 || response.StatusCode >= 300 { 4518 return out, metadata, awsRestxml_deserializeOpErrorXmlEmptyStrings(response, &metadata) 4519 } 4520 output := &XmlEmptyStringsOutput{} 4521 out.Result = output 4522 4523 var buff [1024]byte 4524 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4525 body := io.TeeReader(response.Body, ringBuffer) 4526 rootDecoder := xml.NewDecoder(body) 4527 t, err := smithyxml.FetchRootElement(rootDecoder) 4528 if err == io.EOF { 4529 return out, metadata, nil 4530 } 4531 if err != nil { 4532 var snapshot bytes.Buffer 4533 io.Copy(&snapshot, ringBuffer) 4534 return out, metadata, &smithy.DeserializationError{ 4535 Err: fmt.Errorf("failed to decode response body, %w", err), 4536 Snapshot: snapshot.Bytes(), 4537 } 4538 } 4539 4540 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4541 err = awsRestxml_deserializeOpDocumentXmlEmptyStringsOutput(&output, decoder) 4542 if err != nil { 4543 var snapshot bytes.Buffer 4544 io.Copy(&snapshot, ringBuffer) 4545 return out, metadata, &smithy.DeserializationError{ 4546 Err: fmt.Errorf("failed to decode response body, %w", err), 4547 Snapshot: snapshot.Bytes(), 4548 } 4549 } 4550 4551 return out, metadata, err 4552} 4553 4554func awsRestxml_deserializeOpErrorXmlEmptyStrings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4555 var errorBuffer bytes.Buffer 4556 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4557 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4558 } 4559 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4560 4561 errorCode := "UnknownError" 4562 errorMessage := errorCode 4563 4564 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4565 if err != nil { 4566 return err 4567 } 4568 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4569 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4570 } 4571 if len(errorComponents.Code) != 0 { 4572 errorCode = errorComponents.Code 4573 } 4574 if len(errorComponents.Message) != 0 { 4575 errorMessage = errorComponents.Message 4576 } 4577 errorBody.Seek(0, io.SeekStart) 4578 switch { 4579 default: 4580 genericError := &smithy.GenericAPIError{ 4581 Code: errorCode, 4582 Message: errorMessage, 4583 } 4584 return genericError 4585 4586 } 4587} 4588 4589func awsRestxml_deserializeOpDocumentXmlEmptyStringsOutput(v **XmlEmptyStringsOutput, decoder smithyxml.NodeDecoder) error { 4590 if v == nil { 4591 return fmt.Errorf("unexpected nil of type %T", v) 4592 } 4593 var sv *XmlEmptyStringsOutput 4594 if *v == nil { 4595 sv = &XmlEmptyStringsOutput{} 4596 } else { 4597 sv = *v 4598 } 4599 4600 for { 4601 t, done, err := decoder.Token() 4602 if err != nil { 4603 return err 4604 } 4605 if done { 4606 break 4607 } 4608 originalDecoder := decoder 4609 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4610 switch { 4611 case strings.EqualFold("emptyString", t.Name.Local): 4612 val, err := decoder.Value() 4613 if err != nil { 4614 return err 4615 } 4616 if val == nil { 4617 break 4618 } 4619 { 4620 xtv := string(val) 4621 sv.EmptyString = ptr.String(xtv) 4622 } 4623 4624 default: 4625 // Do nothing and ignore the unexpected tag element 4626 err = decoder.Decoder.Skip() 4627 if err != nil { 4628 return err 4629 } 4630 4631 } 4632 decoder = originalDecoder 4633 } 4634 *v = sv 4635 return nil 4636} 4637 4638type awsRestxml_deserializeOpXmlEnums struct { 4639} 4640 4641func (*awsRestxml_deserializeOpXmlEnums) ID() string { 4642 return "OperationDeserializer" 4643} 4644 4645func (m *awsRestxml_deserializeOpXmlEnums) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4646 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4647) { 4648 out, metadata, err = next.HandleDeserialize(ctx, in) 4649 if err != nil { 4650 return out, metadata, err 4651 } 4652 4653 response, ok := out.RawResponse.(*smithyhttp.Response) 4654 if !ok { 4655 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4656 } 4657 4658 if response.StatusCode < 200 || response.StatusCode >= 300 { 4659 return out, metadata, awsRestxml_deserializeOpErrorXmlEnums(response, &metadata) 4660 } 4661 output := &XmlEnumsOutput{} 4662 out.Result = output 4663 4664 var buff [1024]byte 4665 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4666 body := io.TeeReader(response.Body, ringBuffer) 4667 rootDecoder := xml.NewDecoder(body) 4668 t, err := smithyxml.FetchRootElement(rootDecoder) 4669 if err == io.EOF { 4670 return out, metadata, nil 4671 } 4672 if err != nil { 4673 var snapshot bytes.Buffer 4674 io.Copy(&snapshot, ringBuffer) 4675 return out, metadata, &smithy.DeserializationError{ 4676 Err: fmt.Errorf("failed to decode response body, %w", err), 4677 Snapshot: snapshot.Bytes(), 4678 } 4679 } 4680 4681 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4682 err = awsRestxml_deserializeOpDocumentXmlEnumsOutput(&output, decoder) 4683 if err != nil { 4684 var snapshot bytes.Buffer 4685 io.Copy(&snapshot, ringBuffer) 4686 return out, metadata, &smithy.DeserializationError{ 4687 Err: fmt.Errorf("failed to decode response body, %w", err), 4688 Snapshot: snapshot.Bytes(), 4689 } 4690 } 4691 4692 return out, metadata, err 4693} 4694 4695func awsRestxml_deserializeOpErrorXmlEnums(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4696 var errorBuffer bytes.Buffer 4697 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4698 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4699 } 4700 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4701 4702 errorCode := "UnknownError" 4703 errorMessage := errorCode 4704 4705 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4706 if err != nil { 4707 return err 4708 } 4709 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4710 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4711 } 4712 if len(errorComponents.Code) != 0 { 4713 errorCode = errorComponents.Code 4714 } 4715 if len(errorComponents.Message) != 0 { 4716 errorMessage = errorComponents.Message 4717 } 4718 errorBody.Seek(0, io.SeekStart) 4719 switch { 4720 default: 4721 genericError := &smithy.GenericAPIError{ 4722 Code: errorCode, 4723 Message: errorMessage, 4724 } 4725 return genericError 4726 4727 } 4728} 4729 4730func awsRestxml_deserializeOpDocumentXmlEnumsOutput(v **XmlEnumsOutput, decoder smithyxml.NodeDecoder) error { 4731 if v == nil { 4732 return fmt.Errorf("unexpected nil of type %T", v) 4733 } 4734 var sv *XmlEnumsOutput 4735 if *v == nil { 4736 sv = &XmlEnumsOutput{} 4737 } else { 4738 sv = *v 4739 } 4740 4741 for { 4742 t, done, err := decoder.Token() 4743 if err != nil { 4744 return err 4745 } 4746 if done { 4747 break 4748 } 4749 originalDecoder := decoder 4750 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4751 switch { 4752 case strings.EqualFold("fooEnum1", t.Name.Local): 4753 val, err := decoder.Value() 4754 if err != nil { 4755 return err 4756 } 4757 if val == nil { 4758 break 4759 } 4760 { 4761 xtv := string(val) 4762 sv.FooEnum1 = types.FooEnum(xtv) 4763 } 4764 4765 case strings.EqualFold("fooEnum2", t.Name.Local): 4766 val, err := decoder.Value() 4767 if err != nil { 4768 return err 4769 } 4770 if val == nil { 4771 break 4772 } 4773 { 4774 xtv := string(val) 4775 sv.FooEnum2 = types.FooEnum(xtv) 4776 } 4777 4778 case strings.EqualFold("fooEnum3", t.Name.Local): 4779 val, err := decoder.Value() 4780 if err != nil { 4781 return err 4782 } 4783 if val == nil { 4784 break 4785 } 4786 { 4787 xtv := string(val) 4788 sv.FooEnum3 = types.FooEnum(xtv) 4789 } 4790 4791 case strings.EqualFold("fooEnumList", t.Name.Local): 4792 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4793 if err := awsRestxml_deserializeDocumentFooEnumList(&sv.FooEnumList, nodeDecoder); err != nil { 4794 return err 4795 } 4796 4797 case strings.EqualFold("fooEnumMap", t.Name.Local): 4798 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4799 if err := awsRestxml_deserializeDocumentFooEnumMap(&sv.FooEnumMap, nodeDecoder); err != nil { 4800 return err 4801 } 4802 4803 case strings.EqualFold("fooEnumSet", t.Name.Local): 4804 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4805 if err := awsRestxml_deserializeDocumentFooEnumSet(&sv.FooEnumSet, nodeDecoder); err != nil { 4806 return err 4807 } 4808 4809 default: 4810 // Do nothing and ignore the unexpected tag element 4811 err = decoder.Decoder.Skip() 4812 if err != nil { 4813 return err 4814 } 4815 4816 } 4817 decoder = originalDecoder 4818 } 4819 *v = sv 4820 return nil 4821} 4822 4823type awsRestxml_deserializeOpXmlLists struct { 4824} 4825 4826func (*awsRestxml_deserializeOpXmlLists) ID() string { 4827 return "OperationDeserializer" 4828} 4829 4830func (m *awsRestxml_deserializeOpXmlLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4831 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4832) { 4833 out, metadata, err = next.HandleDeserialize(ctx, in) 4834 if err != nil { 4835 return out, metadata, err 4836 } 4837 4838 response, ok := out.RawResponse.(*smithyhttp.Response) 4839 if !ok { 4840 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4841 } 4842 4843 if response.StatusCode < 200 || response.StatusCode >= 300 { 4844 return out, metadata, awsRestxml_deserializeOpErrorXmlLists(response, &metadata) 4845 } 4846 output := &XmlListsOutput{} 4847 out.Result = output 4848 4849 var buff [1024]byte 4850 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4851 body := io.TeeReader(response.Body, ringBuffer) 4852 rootDecoder := xml.NewDecoder(body) 4853 t, err := smithyxml.FetchRootElement(rootDecoder) 4854 if err == io.EOF { 4855 return out, metadata, nil 4856 } 4857 if err != nil { 4858 var snapshot bytes.Buffer 4859 io.Copy(&snapshot, ringBuffer) 4860 return out, metadata, &smithy.DeserializationError{ 4861 Err: fmt.Errorf("failed to decode response body, %w", err), 4862 Snapshot: snapshot.Bytes(), 4863 } 4864 } 4865 4866 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4867 err = awsRestxml_deserializeOpDocumentXmlListsOutput(&output, decoder) 4868 if err != nil { 4869 var snapshot bytes.Buffer 4870 io.Copy(&snapshot, ringBuffer) 4871 return out, metadata, &smithy.DeserializationError{ 4872 Err: fmt.Errorf("failed to decode response body, %w", err), 4873 Snapshot: snapshot.Bytes(), 4874 } 4875 } 4876 4877 return out, metadata, err 4878} 4879 4880func awsRestxml_deserializeOpErrorXmlLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4881 var errorBuffer bytes.Buffer 4882 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4883 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4884 } 4885 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4886 4887 errorCode := "UnknownError" 4888 errorMessage := errorCode 4889 4890 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 4891 if err != nil { 4892 return err 4893 } 4894 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4895 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4896 } 4897 if len(errorComponents.Code) != 0 { 4898 errorCode = errorComponents.Code 4899 } 4900 if len(errorComponents.Message) != 0 { 4901 errorMessage = errorComponents.Message 4902 } 4903 errorBody.Seek(0, io.SeekStart) 4904 switch { 4905 default: 4906 genericError := &smithy.GenericAPIError{ 4907 Code: errorCode, 4908 Message: errorMessage, 4909 } 4910 return genericError 4911 4912 } 4913} 4914 4915func awsRestxml_deserializeOpDocumentXmlListsOutput(v **XmlListsOutput, decoder smithyxml.NodeDecoder) error { 4916 if v == nil { 4917 return fmt.Errorf("unexpected nil of type %T", v) 4918 } 4919 var sv *XmlListsOutput 4920 if *v == nil { 4921 sv = &XmlListsOutput{} 4922 } else { 4923 sv = *v 4924 } 4925 4926 for { 4927 t, done, err := decoder.Token() 4928 if err != nil { 4929 return err 4930 } 4931 if done { 4932 break 4933 } 4934 originalDecoder := decoder 4935 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4936 switch { 4937 case strings.EqualFold("booleanList", t.Name.Local): 4938 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4939 if err := awsRestxml_deserializeDocumentBooleanList(&sv.BooleanList, nodeDecoder); err != nil { 4940 return err 4941 } 4942 4943 case strings.EqualFold("enumList", t.Name.Local): 4944 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4945 if err := awsRestxml_deserializeDocumentFooEnumList(&sv.EnumList, nodeDecoder); err != nil { 4946 return err 4947 } 4948 4949 case strings.EqualFold("flattenedList", t.Name.Local): 4950 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4951 if err := awsRestxml_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList, nodeDecoder); err != nil { 4952 return err 4953 } 4954 4955 case strings.EqualFold("customName", t.Name.Local): 4956 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4957 if err := awsRestxml_deserializeDocumentRenamedListMembersUnwrapped(&sv.FlattenedList2, nodeDecoder); err != nil { 4958 return err 4959 } 4960 4961 case strings.EqualFold("flattenedListWithMemberNamespace", t.Name.Local): 4962 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4963 if err := awsRestxml_deserializeDocumentListWithMemberNamespaceUnwrapped(&sv.FlattenedListWithMemberNamespace, nodeDecoder); err != nil { 4964 return err 4965 } 4966 4967 case strings.EqualFold("flattenedListWithNamespace", t.Name.Local): 4968 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4969 if err := awsRestxml_deserializeDocumentListWithNamespaceUnwrapped(&sv.FlattenedListWithNamespace, nodeDecoder); err != nil { 4970 return err 4971 } 4972 4973 case strings.EqualFold("integerList", t.Name.Local): 4974 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4975 if err := awsRestxml_deserializeDocumentIntegerList(&sv.IntegerList, nodeDecoder); err != nil { 4976 return err 4977 } 4978 4979 case strings.EqualFold("nestedStringList", t.Name.Local): 4980 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4981 if err := awsRestxml_deserializeDocumentNestedStringList(&sv.NestedStringList, nodeDecoder); err != nil { 4982 return err 4983 } 4984 4985 case strings.EqualFold("renamed", t.Name.Local): 4986 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4987 if err := awsRestxml_deserializeDocumentRenamedListMembers(&sv.RenamedListMembers, nodeDecoder); err != nil { 4988 return err 4989 } 4990 4991 case strings.EqualFold("stringList", t.Name.Local): 4992 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4993 if err := awsRestxml_deserializeDocumentStringList(&sv.StringList, nodeDecoder); err != nil { 4994 return err 4995 } 4996 4997 case strings.EqualFold("stringSet", t.Name.Local): 4998 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4999 if err := awsRestxml_deserializeDocumentStringSet(&sv.StringSet, nodeDecoder); err != nil { 5000 return err 5001 } 5002 5003 case strings.EqualFold("myStructureList", t.Name.Local): 5004 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5005 if err := awsRestxml_deserializeDocumentStructureList(&sv.StructureList, nodeDecoder); err != nil { 5006 return err 5007 } 5008 5009 case strings.EqualFold("timestampList", t.Name.Local): 5010 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5011 if err := awsRestxml_deserializeDocumentTimestampList(&sv.TimestampList, nodeDecoder); err != nil { 5012 return err 5013 } 5014 5015 default: 5016 // Do nothing and ignore the unexpected tag element 5017 err = decoder.Decoder.Skip() 5018 if err != nil { 5019 return err 5020 } 5021 5022 } 5023 decoder = originalDecoder 5024 } 5025 *v = sv 5026 return nil 5027} 5028 5029type awsRestxml_deserializeOpXmlMaps struct { 5030} 5031 5032func (*awsRestxml_deserializeOpXmlMaps) ID() string { 5033 return "OperationDeserializer" 5034} 5035 5036func (m *awsRestxml_deserializeOpXmlMaps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5037 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5038) { 5039 out, metadata, err = next.HandleDeserialize(ctx, in) 5040 if err != nil { 5041 return out, metadata, err 5042 } 5043 5044 response, ok := out.RawResponse.(*smithyhttp.Response) 5045 if !ok { 5046 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5047 } 5048 5049 if response.StatusCode < 200 || response.StatusCode >= 300 { 5050 return out, metadata, awsRestxml_deserializeOpErrorXmlMaps(response, &metadata) 5051 } 5052 output := &XmlMapsOutput{} 5053 out.Result = output 5054 5055 var buff [1024]byte 5056 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5057 body := io.TeeReader(response.Body, ringBuffer) 5058 rootDecoder := xml.NewDecoder(body) 5059 t, err := smithyxml.FetchRootElement(rootDecoder) 5060 if err == io.EOF { 5061 return out, metadata, nil 5062 } 5063 if err != nil { 5064 var snapshot bytes.Buffer 5065 io.Copy(&snapshot, ringBuffer) 5066 return out, metadata, &smithy.DeserializationError{ 5067 Err: fmt.Errorf("failed to decode response body, %w", err), 5068 Snapshot: snapshot.Bytes(), 5069 } 5070 } 5071 5072 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5073 err = awsRestxml_deserializeOpDocumentXmlMapsOutput(&output, decoder) 5074 if err != nil { 5075 var snapshot bytes.Buffer 5076 io.Copy(&snapshot, ringBuffer) 5077 return out, metadata, &smithy.DeserializationError{ 5078 Err: fmt.Errorf("failed to decode response body, %w", err), 5079 Snapshot: snapshot.Bytes(), 5080 } 5081 } 5082 5083 return out, metadata, err 5084} 5085 5086func awsRestxml_deserializeOpErrorXmlMaps(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5087 var errorBuffer bytes.Buffer 5088 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5089 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5090 } 5091 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5092 5093 errorCode := "UnknownError" 5094 errorMessage := errorCode 5095 5096 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5097 if err != nil { 5098 return err 5099 } 5100 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5101 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5102 } 5103 if len(errorComponents.Code) != 0 { 5104 errorCode = errorComponents.Code 5105 } 5106 if len(errorComponents.Message) != 0 { 5107 errorMessage = errorComponents.Message 5108 } 5109 errorBody.Seek(0, io.SeekStart) 5110 switch { 5111 default: 5112 genericError := &smithy.GenericAPIError{ 5113 Code: errorCode, 5114 Message: errorMessage, 5115 } 5116 return genericError 5117 5118 } 5119} 5120 5121func awsRestxml_deserializeOpDocumentXmlMapsOutput(v **XmlMapsOutput, decoder smithyxml.NodeDecoder) error { 5122 if v == nil { 5123 return fmt.Errorf("unexpected nil of type %T", v) 5124 } 5125 var sv *XmlMapsOutput 5126 if *v == nil { 5127 sv = &XmlMapsOutput{} 5128 } else { 5129 sv = *v 5130 } 5131 5132 for { 5133 t, done, err := decoder.Token() 5134 if err != nil { 5135 return err 5136 } 5137 if done { 5138 break 5139 } 5140 originalDecoder := decoder 5141 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5142 switch { 5143 case strings.EqualFold("myMap", t.Name.Local): 5144 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5145 if err := awsRestxml_deserializeDocumentXmlMapsInputOutputMap(&sv.MyMap, nodeDecoder); err != nil { 5146 return err 5147 } 5148 5149 default: 5150 // Do nothing and ignore the unexpected tag element 5151 err = decoder.Decoder.Skip() 5152 if err != nil { 5153 return err 5154 } 5155 5156 } 5157 decoder = originalDecoder 5158 } 5159 *v = sv 5160 return nil 5161} 5162 5163type awsRestxml_deserializeOpXmlMapsXmlName struct { 5164} 5165 5166func (*awsRestxml_deserializeOpXmlMapsXmlName) ID() string { 5167 return "OperationDeserializer" 5168} 5169 5170func (m *awsRestxml_deserializeOpXmlMapsXmlName) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5171 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5172) { 5173 out, metadata, err = next.HandleDeserialize(ctx, in) 5174 if err != nil { 5175 return out, metadata, err 5176 } 5177 5178 response, ok := out.RawResponse.(*smithyhttp.Response) 5179 if !ok { 5180 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5181 } 5182 5183 if response.StatusCode < 200 || response.StatusCode >= 300 { 5184 return out, metadata, awsRestxml_deserializeOpErrorXmlMapsXmlName(response, &metadata) 5185 } 5186 output := &XmlMapsXmlNameOutput{} 5187 out.Result = output 5188 5189 var buff [1024]byte 5190 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5191 body := io.TeeReader(response.Body, ringBuffer) 5192 rootDecoder := xml.NewDecoder(body) 5193 t, err := smithyxml.FetchRootElement(rootDecoder) 5194 if err == io.EOF { 5195 return out, metadata, nil 5196 } 5197 if err != nil { 5198 var snapshot bytes.Buffer 5199 io.Copy(&snapshot, ringBuffer) 5200 return out, metadata, &smithy.DeserializationError{ 5201 Err: fmt.Errorf("failed to decode response body, %w", err), 5202 Snapshot: snapshot.Bytes(), 5203 } 5204 } 5205 5206 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5207 err = awsRestxml_deserializeOpDocumentXmlMapsXmlNameOutput(&output, decoder) 5208 if err != nil { 5209 var snapshot bytes.Buffer 5210 io.Copy(&snapshot, ringBuffer) 5211 return out, metadata, &smithy.DeserializationError{ 5212 Err: fmt.Errorf("failed to decode response body, %w", err), 5213 Snapshot: snapshot.Bytes(), 5214 } 5215 } 5216 5217 return out, metadata, err 5218} 5219 5220func awsRestxml_deserializeOpErrorXmlMapsXmlName(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5221 var errorBuffer bytes.Buffer 5222 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5223 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5224 } 5225 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5226 5227 errorCode := "UnknownError" 5228 errorMessage := errorCode 5229 5230 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5231 if err != nil { 5232 return err 5233 } 5234 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5235 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5236 } 5237 if len(errorComponents.Code) != 0 { 5238 errorCode = errorComponents.Code 5239 } 5240 if len(errorComponents.Message) != 0 { 5241 errorMessage = errorComponents.Message 5242 } 5243 errorBody.Seek(0, io.SeekStart) 5244 switch { 5245 default: 5246 genericError := &smithy.GenericAPIError{ 5247 Code: errorCode, 5248 Message: errorMessage, 5249 } 5250 return genericError 5251 5252 } 5253} 5254 5255func awsRestxml_deserializeOpDocumentXmlMapsXmlNameOutput(v **XmlMapsXmlNameOutput, decoder smithyxml.NodeDecoder) error { 5256 if v == nil { 5257 return fmt.Errorf("unexpected nil of type %T", v) 5258 } 5259 var sv *XmlMapsXmlNameOutput 5260 if *v == nil { 5261 sv = &XmlMapsXmlNameOutput{} 5262 } else { 5263 sv = *v 5264 } 5265 5266 for { 5267 t, done, err := decoder.Token() 5268 if err != nil { 5269 return err 5270 } 5271 if done { 5272 break 5273 } 5274 originalDecoder := decoder 5275 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5276 switch { 5277 case strings.EqualFold("myMap", t.Name.Local): 5278 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5279 if err := awsRestxml_deserializeDocumentXmlMapsXmlNameInputOutputMap(&sv.MyMap, nodeDecoder); err != nil { 5280 return err 5281 } 5282 5283 default: 5284 // Do nothing and ignore the unexpected tag element 5285 err = decoder.Decoder.Skip() 5286 if err != nil { 5287 return err 5288 } 5289 5290 } 5291 decoder = originalDecoder 5292 } 5293 *v = sv 5294 return nil 5295} 5296 5297type awsRestxml_deserializeOpXmlNamespaces struct { 5298} 5299 5300func (*awsRestxml_deserializeOpXmlNamespaces) ID() string { 5301 return "OperationDeserializer" 5302} 5303 5304func (m *awsRestxml_deserializeOpXmlNamespaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5305 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5306) { 5307 out, metadata, err = next.HandleDeserialize(ctx, in) 5308 if err != nil { 5309 return out, metadata, err 5310 } 5311 5312 response, ok := out.RawResponse.(*smithyhttp.Response) 5313 if !ok { 5314 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5315 } 5316 5317 if response.StatusCode < 200 || response.StatusCode >= 300 { 5318 return out, metadata, awsRestxml_deserializeOpErrorXmlNamespaces(response, &metadata) 5319 } 5320 output := &XmlNamespacesOutput{} 5321 out.Result = output 5322 5323 var buff [1024]byte 5324 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5325 body := io.TeeReader(response.Body, ringBuffer) 5326 rootDecoder := xml.NewDecoder(body) 5327 t, err := smithyxml.FetchRootElement(rootDecoder) 5328 if err == io.EOF { 5329 return out, metadata, nil 5330 } 5331 if err != nil { 5332 var snapshot bytes.Buffer 5333 io.Copy(&snapshot, ringBuffer) 5334 return out, metadata, &smithy.DeserializationError{ 5335 Err: fmt.Errorf("failed to decode response body, %w", err), 5336 Snapshot: snapshot.Bytes(), 5337 } 5338 } 5339 5340 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5341 err = awsRestxml_deserializeOpDocumentXmlNamespacesOutput(&output, decoder) 5342 if err != nil { 5343 var snapshot bytes.Buffer 5344 io.Copy(&snapshot, ringBuffer) 5345 return out, metadata, &smithy.DeserializationError{ 5346 Err: fmt.Errorf("failed to decode response body, %w", err), 5347 Snapshot: snapshot.Bytes(), 5348 } 5349 } 5350 5351 return out, metadata, err 5352} 5353 5354func awsRestxml_deserializeOpErrorXmlNamespaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5355 var errorBuffer bytes.Buffer 5356 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5357 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5358 } 5359 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5360 5361 errorCode := "UnknownError" 5362 errorMessage := errorCode 5363 5364 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5365 if err != nil { 5366 return err 5367 } 5368 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5369 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5370 } 5371 if len(errorComponents.Code) != 0 { 5372 errorCode = errorComponents.Code 5373 } 5374 if len(errorComponents.Message) != 0 { 5375 errorMessage = errorComponents.Message 5376 } 5377 errorBody.Seek(0, io.SeekStart) 5378 switch { 5379 default: 5380 genericError := &smithy.GenericAPIError{ 5381 Code: errorCode, 5382 Message: errorMessage, 5383 } 5384 return genericError 5385 5386 } 5387} 5388 5389func awsRestxml_deserializeOpDocumentXmlNamespacesOutput(v **XmlNamespacesOutput, decoder smithyxml.NodeDecoder) error { 5390 if v == nil { 5391 return fmt.Errorf("unexpected nil of type %T", v) 5392 } 5393 var sv *XmlNamespacesOutput 5394 if *v == nil { 5395 sv = &XmlNamespacesOutput{} 5396 } else { 5397 sv = *v 5398 } 5399 5400 for { 5401 t, done, err := decoder.Token() 5402 if err != nil { 5403 return err 5404 } 5405 if done { 5406 break 5407 } 5408 originalDecoder := decoder 5409 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5410 switch { 5411 case strings.EqualFold("nested", t.Name.Local): 5412 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5413 if err := awsRestxml_deserializeDocumentXmlNamespaceNested(&sv.Nested, nodeDecoder); err != nil { 5414 return err 5415 } 5416 5417 default: 5418 // Do nothing and ignore the unexpected tag element 5419 err = decoder.Decoder.Skip() 5420 if err != nil { 5421 return err 5422 } 5423 5424 } 5425 decoder = originalDecoder 5426 } 5427 *v = sv 5428 return nil 5429} 5430 5431type awsRestxml_deserializeOpXmlTimestamps struct { 5432} 5433 5434func (*awsRestxml_deserializeOpXmlTimestamps) ID() string { 5435 return "OperationDeserializer" 5436} 5437 5438func (m *awsRestxml_deserializeOpXmlTimestamps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5439 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5440) { 5441 out, metadata, err = next.HandleDeserialize(ctx, in) 5442 if err != nil { 5443 return out, metadata, err 5444 } 5445 5446 response, ok := out.RawResponse.(*smithyhttp.Response) 5447 if !ok { 5448 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5449 } 5450 5451 if response.StatusCode < 200 || response.StatusCode >= 300 { 5452 return out, metadata, awsRestxml_deserializeOpErrorXmlTimestamps(response, &metadata) 5453 } 5454 output := &XmlTimestampsOutput{} 5455 out.Result = output 5456 5457 var buff [1024]byte 5458 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5459 body := io.TeeReader(response.Body, ringBuffer) 5460 rootDecoder := xml.NewDecoder(body) 5461 t, err := smithyxml.FetchRootElement(rootDecoder) 5462 if err == io.EOF { 5463 return out, metadata, nil 5464 } 5465 if err != nil { 5466 var snapshot bytes.Buffer 5467 io.Copy(&snapshot, ringBuffer) 5468 return out, metadata, &smithy.DeserializationError{ 5469 Err: fmt.Errorf("failed to decode response body, %w", err), 5470 Snapshot: snapshot.Bytes(), 5471 } 5472 } 5473 5474 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5475 err = awsRestxml_deserializeOpDocumentXmlTimestampsOutput(&output, decoder) 5476 if err != nil { 5477 var snapshot bytes.Buffer 5478 io.Copy(&snapshot, ringBuffer) 5479 return out, metadata, &smithy.DeserializationError{ 5480 Err: fmt.Errorf("failed to decode response body, %w", err), 5481 Snapshot: snapshot.Bytes(), 5482 } 5483 } 5484 5485 return out, metadata, err 5486} 5487 5488func awsRestxml_deserializeOpErrorXmlTimestamps(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5489 var errorBuffer bytes.Buffer 5490 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5491 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5492 } 5493 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5494 5495 errorCode := "UnknownError" 5496 errorMessage := errorCode 5497 5498 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5499 if err != nil { 5500 return err 5501 } 5502 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5503 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5504 } 5505 if len(errorComponents.Code) != 0 { 5506 errorCode = errorComponents.Code 5507 } 5508 if len(errorComponents.Message) != 0 { 5509 errorMessage = errorComponents.Message 5510 } 5511 errorBody.Seek(0, io.SeekStart) 5512 switch { 5513 default: 5514 genericError := &smithy.GenericAPIError{ 5515 Code: errorCode, 5516 Message: errorMessage, 5517 } 5518 return genericError 5519 5520 } 5521} 5522 5523func awsRestxml_deserializeOpDocumentXmlTimestampsOutput(v **XmlTimestampsOutput, decoder smithyxml.NodeDecoder) error { 5524 if v == nil { 5525 return fmt.Errorf("unexpected nil of type %T", v) 5526 } 5527 var sv *XmlTimestampsOutput 5528 if *v == nil { 5529 sv = &XmlTimestampsOutput{} 5530 } else { 5531 sv = *v 5532 } 5533 5534 for { 5535 t, done, err := decoder.Token() 5536 if err != nil { 5537 return err 5538 } 5539 if done { 5540 break 5541 } 5542 originalDecoder := decoder 5543 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5544 switch { 5545 case strings.EqualFold("dateTime", t.Name.Local): 5546 val, err := decoder.Value() 5547 if err != nil { 5548 return err 5549 } 5550 if val == nil { 5551 break 5552 } 5553 { 5554 xtv := string(val) 5555 t, err := smithytime.ParseDateTime(xtv) 5556 if err != nil { 5557 return err 5558 } 5559 sv.DateTime = ptr.Time(t) 5560 } 5561 5562 case strings.EqualFold("epochSeconds", t.Name.Local): 5563 val, err := decoder.Value() 5564 if err != nil { 5565 return err 5566 } 5567 if val == nil { 5568 break 5569 } 5570 { 5571 xtv := string(val) 5572 f64, err := strconv.ParseFloat(xtv, 64) 5573 if err != nil { 5574 return err 5575 } 5576 sv.EpochSeconds = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5577 } 5578 5579 case strings.EqualFold("httpDate", t.Name.Local): 5580 val, err := decoder.Value() 5581 if err != nil { 5582 return err 5583 } 5584 if val == nil { 5585 break 5586 } 5587 { 5588 xtv := string(val) 5589 t, err := smithytime.ParseHTTPDate(xtv) 5590 if err != nil { 5591 return err 5592 } 5593 sv.HttpDate = ptr.Time(t) 5594 } 5595 5596 case strings.EqualFold("normal", t.Name.Local): 5597 val, err := decoder.Value() 5598 if err != nil { 5599 return err 5600 } 5601 if val == nil { 5602 break 5603 } 5604 { 5605 xtv := string(val) 5606 t, err := smithytime.ParseDateTime(xtv) 5607 if err != nil { 5608 return err 5609 } 5610 sv.Normal = ptr.Time(t) 5611 } 5612 5613 default: 5614 // Do nothing and ignore the unexpected tag element 5615 err = decoder.Decoder.Skip() 5616 if err != nil { 5617 return err 5618 } 5619 5620 } 5621 decoder = originalDecoder 5622 } 5623 *v = sv 5624 return nil 5625} 5626 5627type awsRestxml_deserializeOpXmlUnions struct { 5628} 5629 5630func (*awsRestxml_deserializeOpXmlUnions) ID() string { 5631 return "OperationDeserializer" 5632} 5633 5634func (m *awsRestxml_deserializeOpXmlUnions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5635 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5636) { 5637 out, metadata, err = next.HandleDeserialize(ctx, in) 5638 if err != nil { 5639 return out, metadata, err 5640 } 5641 5642 response, ok := out.RawResponse.(*smithyhttp.Response) 5643 if !ok { 5644 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5645 } 5646 5647 if response.StatusCode < 200 || response.StatusCode >= 300 { 5648 return out, metadata, awsRestxml_deserializeOpErrorXmlUnions(response, &metadata) 5649 } 5650 output := &XmlUnionsOutput{} 5651 out.Result = output 5652 5653 var buff [1024]byte 5654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5655 body := io.TeeReader(response.Body, ringBuffer) 5656 rootDecoder := xml.NewDecoder(body) 5657 t, err := smithyxml.FetchRootElement(rootDecoder) 5658 if err == io.EOF { 5659 return out, metadata, nil 5660 } 5661 if err != nil { 5662 var snapshot bytes.Buffer 5663 io.Copy(&snapshot, ringBuffer) 5664 return out, metadata, &smithy.DeserializationError{ 5665 Err: fmt.Errorf("failed to decode response body, %w", err), 5666 Snapshot: snapshot.Bytes(), 5667 } 5668 } 5669 5670 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5671 err = awsRestxml_deserializeOpDocumentXmlUnionsOutput(&output, decoder) 5672 if err != nil { 5673 var snapshot bytes.Buffer 5674 io.Copy(&snapshot, ringBuffer) 5675 return out, metadata, &smithy.DeserializationError{ 5676 Err: fmt.Errorf("failed to decode response body, %w", err), 5677 Snapshot: snapshot.Bytes(), 5678 } 5679 } 5680 5681 return out, metadata, err 5682} 5683 5684func awsRestxml_deserializeOpErrorXmlUnions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5685 var errorBuffer bytes.Buffer 5686 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5687 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5688 } 5689 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5690 5691 errorCode := "UnknownError" 5692 errorMessage := errorCode 5693 5694 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 5695 if err != nil { 5696 return err 5697 } 5698 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5699 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5700 } 5701 if len(errorComponents.Code) != 0 { 5702 errorCode = errorComponents.Code 5703 } 5704 if len(errorComponents.Message) != 0 { 5705 errorMessage = errorComponents.Message 5706 } 5707 errorBody.Seek(0, io.SeekStart) 5708 switch { 5709 default: 5710 genericError := &smithy.GenericAPIError{ 5711 Code: errorCode, 5712 Message: errorMessage, 5713 } 5714 return genericError 5715 5716 } 5717} 5718 5719func awsRestxml_deserializeOpDocumentXmlUnionsOutput(v **XmlUnionsOutput, decoder smithyxml.NodeDecoder) error { 5720 if v == nil { 5721 return fmt.Errorf("unexpected nil of type %T", v) 5722 } 5723 var sv *XmlUnionsOutput 5724 if *v == nil { 5725 sv = &XmlUnionsOutput{} 5726 } else { 5727 sv = *v 5728 } 5729 5730 for { 5731 t, done, err := decoder.Token() 5732 if err != nil { 5733 return err 5734 } 5735 if done { 5736 break 5737 } 5738 originalDecoder := decoder 5739 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5740 switch { 5741 case strings.EqualFold("unionValue", t.Name.Local): 5742 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5743 if err := awsRestxml_deserializeDocumentXmlUnionShape(&sv.UnionValue, nodeDecoder); err != nil { 5744 return err 5745 } 5746 5747 default: 5748 // Do nothing and ignore the unexpected tag element 5749 err = decoder.Decoder.Skip() 5750 if err != nil { 5751 return err 5752 } 5753 5754 } 5755 decoder = originalDecoder 5756 } 5757 *v = sv 5758 return nil 5759} 5760 5761func awsRestxml_deserializeOpHttpBindingsComplexError(v *types.ComplexError, response *smithyhttp.Response) error { 5762 if v == nil { 5763 return fmt.Errorf("unsupported deserialization for nil %T", v) 5764 } 5765 5766 if headerValues := response.Header.Values("X-Header"); len(headerValues) != 0 { 5767 headerValues[0] = strings.TrimSpace(headerValues[0]) 5768 v.Header = ptr.String(headerValues[0]) 5769 } 5770 5771 return nil 5772} 5773func awsRestxml_deserializeErrorComplexError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5774 output := &types.ComplexError{} 5775 if err := awsRestxml_deserializeOpHttpBindingsComplexError(output, response); err != nil { 5776 return &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response error with invalid HTTP bindings, %w", err)} 5777 } 5778 var buff [1024]byte 5779 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5780 body := io.TeeReader(errorBody, ringBuffer) 5781 rootDecoder := xml.NewDecoder(body) 5782 t, err := smithyxml.FetchRootElement(rootDecoder) 5783 if err == io.EOF { 5784 return output 5785 } 5786 if err != nil { 5787 var snapshot bytes.Buffer 5788 io.Copy(&snapshot, ringBuffer) 5789 return &smithy.DeserializationError{ 5790 Err: fmt.Errorf("failed to decode response body, %w", err), 5791 Snapshot: snapshot.Bytes(), 5792 } 5793 } 5794 5795 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5796 t, err = decoder.GetElement("Error") 5797 if err != nil { 5798 var snapshot bytes.Buffer 5799 io.Copy(&snapshot, ringBuffer) 5800 return &smithy.DeserializationError{ 5801 Err: fmt.Errorf("failed to decode response body, %w", err), 5802 Snapshot: snapshot.Bytes(), 5803 } 5804 } 5805 5806 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5807 err = awsRestxml_deserializeDocumentComplexError(&output, decoder) 5808 if err != nil { 5809 var snapshot bytes.Buffer 5810 io.Copy(&snapshot, ringBuffer) 5811 return &smithy.DeserializationError{ 5812 Err: fmt.Errorf("failed to decode response body, %w", err), 5813 Snapshot: snapshot.Bytes(), 5814 } 5815 } 5816 5817 return output 5818} 5819 5820func awsRestxml_deserializeErrorInvalidGreeting(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5821 output := &types.InvalidGreeting{} 5822 var buff [1024]byte 5823 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5824 body := io.TeeReader(errorBody, ringBuffer) 5825 rootDecoder := xml.NewDecoder(body) 5826 t, err := smithyxml.FetchRootElement(rootDecoder) 5827 if err == io.EOF { 5828 return output 5829 } 5830 if err != nil { 5831 var snapshot bytes.Buffer 5832 io.Copy(&snapshot, ringBuffer) 5833 return &smithy.DeserializationError{ 5834 Err: fmt.Errorf("failed to decode response body, %w", err), 5835 Snapshot: snapshot.Bytes(), 5836 } 5837 } 5838 5839 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5840 t, err = decoder.GetElement("Error") 5841 if err != nil { 5842 var snapshot bytes.Buffer 5843 io.Copy(&snapshot, ringBuffer) 5844 return &smithy.DeserializationError{ 5845 Err: fmt.Errorf("failed to decode response body, %w", err), 5846 Snapshot: snapshot.Bytes(), 5847 } 5848 } 5849 5850 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5851 err = awsRestxml_deserializeDocumentInvalidGreeting(&output, decoder) 5852 if err != nil { 5853 var snapshot bytes.Buffer 5854 io.Copy(&snapshot, ringBuffer) 5855 return &smithy.DeserializationError{ 5856 Err: fmt.Errorf("failed to decode response body, %w", err), 5857 Snapshot: snapshot.Bytes(), 5858 } 5859 } 5860 5861 return output 5862} 5863 5864func awsRestxml_deserializeDocumentComplexError(v **types.ComplexError, decoder smithyxml.NodeDecoder) error { 5865 if v == nil { 5866 return fmt.Errorf("unexpected nil of type %T", v) 5867 } 5868 var sv *types.ComplexError 5869 if *v == nil { 5870 sv = &types.ComplexError{} 5871 } else { 5872 sv = *v 5873 } 5874 5875 for { 5876 t, done, err := decoder.Token() 5877 if err != nil { 5878 return err 5879 } 5880 if done { 5881 break 5882 } 5883 originalDecoder := decoder 5884 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5885 switch { 5886 case strings.EqualFold("Header", t.Name.Local): 5887 val, err := decoder.Value() 5888 if err != nil { 5889 return err 5890 } 5891 if val == nil { 5892 break 5893 } 5894 { 5895 xtv := string(val) 5896 sv.Header = ptr.String(xtv) 5897 } 5898 5899 case strings.EqualFold("Nested", t.Name.Local): 5900 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5901 if err := awsRestxml_deserializeDocumentComplexNestedErrorData(&sv.Nested, nodeDecoder); err != nil { 5902 return err 5903 } 5904 5905 case strings.EqualFold("TopLevel", t.Name.Local): 5906 val, err := decoder.Value() 5907 if err != nil { 5908 return err 5909 } 5910 if val == nil { 5911 break 5912 } 5913 { 5914 xtv := string(val) 5915 sv.TopLevel = ptr.String(xtv) 5916 } 5917 5918 default: 5919 // Do nothing and ignore the unexpected tag element 5920 err = decoder.Decoder.Skip() 5921 if err != nil { 5922 return err 5923 } 5924 5925 } 5926 decoder = originalDecoder 5927 } 5928 *v = sv 5929 return nil 5930} 5931 5932func awsRestxml_deserializeDocumentComplexNestedErrorData(v **types.ComplexNestedErrorData, decoder smithyxml.NodeDecoder) error { 5933 if v == nil { 5934 return fmt.Errorf("unexpected nil of type %T", v) 5935 } 5936 var sv *types.ComplexNestedErrorData 5937 if *v == nil { 5938 sv = &types.ComplexNestedErrorData{} 5939 } else { 5940 sv = *v 5941 } 5942 5943 for { 5944 t, done, err := decoder.Token() 5945 if err != nil { 5946 return err 5947 } 5948 if done { 5949 break 5950 } 5951 originalDecoder := decoder 5952 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5953 switch { 5954 case strings.EqualFold("Foo", t.Name.Local): 5955 val, err := decoder.Value() 5956 if err != nil { 5957 return err 5958 } 5959 if val == nil { 5960 break 5961 } 5962 { 5963 xtv := string(val) 5964 sv.Foo = ptr.String(xtv) 5965 } 5966 5967 default: 5968 // Do nothing and ignore the unexpected tag element 5969 err = decoder.Decoder.Skip() 5970 if err != nil { 5971 return err 5972 } 5973 5974 } 5975 decoder = originalDecoder 5976 } 5977 *v = sv 5978 return nil 5979} 5980 5981func awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNameInputOutputMap(v *map[string]string, decoder smithyxml.NodeDecoder) error { 5982 if v == nil { 5983 return fmt.Errorf("unexpected nil of type %T", v) 5984 } 5985 var sv map[string]string 5986 if *v == nil { 5987 sv = make(map[string]string, 0) 5988 } else { 5989 sv = *v 5990 } 5991 5992 for { 5993 t, done, err := decoder.Token() 5994 if err != nil { 5995 return err 5996 } 5997 if done { 5998 break 5999 } 6000 switch { 6001 case strings.EqualFold("entry", t.Name.Local): 6002 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6003 if err := awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNameInputOutputMapUnwrapped(&sv, entryDecoder); err != nil { 6004 return err 6005 } 6006 6007 default: 6008 err = decoder.Decoder.Skip() 6009 if err != nil { 6010 return err 6011 } 6012 6013 } 6014 } 6015 *v = sv 6016 return nil 6017} 6018 6019func awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNameInputOutputMapUnwrapped(v *map[string]string, decoder smithyxml.NodeDecoder) error { 6020 var sv map[string]string 6021 if *v == nil { 6022 sv = make(map[string]string, 0) 6023 } else { 6024 sv = *v 6025 } 6026 6027 var ek string 6028 var ev string 6029 for { 6030 t, done, err := decoder.Token() 6031 if err != nil { 6032 return err 6033 } 6034 if done { 6035 sv[ek] = ev 6036 break 6037 } 6038 originalDecoder := decoder 6039 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6040 switch { 6041 case strings.EqualFold("K", t.Name.Local): 6042 val, err := decoder.Value() 6043 if err != nil { 6044 return err 6045 } 6046 if val == nil { 6047 break 6048 } 6049 { 6050 xtv := string(val) 6051 ek = xtv 6052 } 6053 6054 case strings.EqualFold("V", t.Name.Local): 6055 val, err := decoder.Value() 6056 if err != nil { 6057 return err 6058 } 6059 if val == nil { 6060 break 6061 } 6062 { 6063 xtv := string(val) 6064 ev = xtv 6065 } 6066 6067 default: 6068 err = decoder.Decoder.Skip() 6069 if err != nil { 6070 return err 6071 } 6072 6073 } 6074 decoder = originalDecoder 6075 } 6076 *v = sv 6077 return nil 6078} 6079func awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNamespaceOutputMap(v *map[string]string, decoder smithyxml.NodeDecoder) error { 6080 if v == nil { 6081 return fmt.Errorf("unexpected nil of type %T", v) 6082 } 6083 var sv map[string]string 6084 if *v == nil { 6085 sv = make(map[string]string, 0) 6086 } else { 6087 sv = *v 6088 } 6089 6090 for { 6091 t, done, err := decoder.Token() 6092 if err != nil { 6093 return err 6094 } 6095 if done { 6096 break 6097 } 6098 switch { 6099 case strings.EqualFold("entry", t.Name.Local): 6100 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6101 if err := awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNamespaceOutputMapUnwrapped(&sv, entryDecoder); err != nil { 6102 return err 6103 } 6104 6105 default: 6106 err = decoder.Decoder.Skip() 6107 if err != nil { 6108 return err 6109 } 6110 6111 } 6112 } 6113 *v = sv 6114 return nil 6115} 6116 6117func awsRestxml_deserializeDocumentFlattenedXmlMapWithXmlNamespaceOutputMapUnwrapped(v *map[string]string, decoder smithyxml.NodeDecoder) error { 6118 var sv map[string]string 6119 if *v == nil { 6120 sv = make(map[string]string, 0) 6121 } else { 6122 sv = *v 6123 } 6124 6125 var ek string 6126 var ev string 6127 for { 6128 t, done, err := decoder.Token() 6129 if err != nil { 6130 return err 6131 } 6132 if done { 6133 sv[ek] = ev 6134 break 6135 } 6136 originalDecoder := decoder 6137 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6138 switch { 6139 case strings.EqualFold("K", t.Name.Local): 6140 val, err := decoder.Value() 6141 if err != nil { 6142 return err 6143 } 6144 if val == nil { 6145 break 6146 } 6147 { 6148 xtv := string(val) 6149 ek = xtv 6150 } 6151 6152 case strings.EqualFold("V", t.Name.Local): 6153 val, err := decoder.Value() 6154 if err != nil { 6155 return err 6156 } 6157 if val == nil { 6158 break 6159 } 6160 { 6161 xtv := string(val) 6162 ev = xtv 6163 } 6164 6165 default: 6166 err = decoder.Decoder.Skip() 6167 if err != nil { 6168 return err 6169 } 6170 6171 } 6172 decoder = originalDecoder 6173 } 6174 *v = sv 6175 return nil 6176} 6177func awsRestxml_deserializeDocumentInvalidGreeting(v **types.InvalidGreeting, decoder smithyxml.NodeDecoder) error { 6178 if v == nil { 6179 return fmt.Errorf("unexpected nil of type %T", v) 6180 } 6181 var sv *types.InvalidGreeting 6182 if *v == nil { 6183 sv = &types.InvalidGreeting{} 6184 } else { 6185 sv = *v 6186 } 6187 6188 for { 6189 t, done, err := decoder.Token() 6190 if err != nil { 6191 return err 6192 } 6193 if done { 6194 break 6195 } 6196 originalDecoder := decoder 6197 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6198 switch { 6199 case strings.EqualFold("Message", t.Name.Local): 6200 val, err := decoder.Value() 6201 if err != nil { 6202 return err 6203 } 6204 if val == nil { 6205 break 6206 } 6207 { 6208 xtv := string(val) 6209 sv.Message = ptr.String(xtv) 6210 } 6211 6212 default: 6213 // Do nothing and ignore the unexpected tag element 6214 err = decoder.Decoder.Skip() 6215 if err != nil { 6216 return err 6217 } 6218 6219 } 6220 decoder = originalDecoder 6221 } 6222 *v = sv 6223 return nil 6224} 6225 6226func awsRestxml_deserializeDocumentListWithMemberNamespace(v *[]string, decoder smithyxml.NodeDecoder) error { 6227 if v == nil { 6228 return fmt.Errorf("unexpected nil of type %T", v) 6229 } 6230 var sv []string 6231 if *v == nil { 6232 sv = make([]string, 0) 6233 } else { 6234 sv = *v 6235 } 6236 6237 originalDecoder := decoder 6238 for { 6239 t, done, err := decoder.Token() 6240 if err != nil { 6241 return err 6242 } 6243 if done { 6244 break 6245 } 6246 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6247 decoder = memberDecoder 6248 switch { 6249 case strings.EqualFold("member", t.Name.Local): 6250 var col string 6251 val, err := decoder.Value() 6252 if err != nil { 6253 return err 6254 } 6255 if val == nil { 6256 break 6257 } 6258 { 6259 xtv := string(val) 6260 col = xtv 6261 } 6262 sv = append(sv, col) 6263 6264 default: 6265 err = decoder.Decoder.Skip() 6266 if err != nil { 6267 return err 6268 } 6269 6270 } 6271 decoder = originalDecoder 6272 } 6273 *v = sv 6274 return nil 6275} 6276 6277func awsRestxml_deserializeDocumentListWithMemberNamespaceUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 6278 var sv []string 6279 if *v == nil { 6280 sv = make([]string, 0) 6281 } else { 6282 sv = *v 6283 } 6284 6285 switch { 6286 default: 6287 var mv string 6288 t := decoder.StartEl 6289 _ = t 6290 val, err := decoder.Value() 6291 if err != nil { 6292 return err 6293 } 6294 if val == nil { 6295 break 6296 } 6297 { 6298 xtv := string(val) 6299 mv = xtv 6300 } 6301 sv = append(sv, mv) 6302 } 6303 *v = sv 6304 return nil 6305} 6306func awsRestxml_deserializeDocumentListWithNamespace(v *[]string, decoder smithyxml.NodeDecoder) error { 6307 if v == nil { 6308 return fmt.Errorf("unexpected nil of type %T", v) 6309 } 6310 var sv []string 6311 if *v == nil { 6312 sv = make([]string, 0) 6313 } else { 6314 sv = *v 6315 } 6316 6317 originalDecoder := decoder 6318 for { 6319 t, done, err := decoder.Token() 6320 if err != nil { 6321 return err 6322 } 6323 if done { 6324 break 6325 } 6326 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6327 decoder = memberDecoder 6328 switch { 6329 case strings.EqualFold("member", t.Name.Local): 6330 var col string 6331 val, err := decoder.Value() 6332 if err != nil { 6333 return err 6334 } 6335 if val == nil { 6336 break 6337 } 6338 { 6339 xtv := string(val) 6340 col = xtv 6341 } 6342 sv = append(sv, col) 6343 6344 default: 6345 err = decoder.Decoder.Skip() 6346 if err != nil { 6347 return err 6348 } 6349 6350 } 6351 decoder = originalDecoder 6352 } 6353 *v = sv 6354 return nil 6355} 6356 6357func awsRestxml_deserializeDocumentListWithNamespaceUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 6358 var sv []string 6359 if *v == nil { 6360 sv = make([]string, 0) 6361 } else { 6362 sv = *v 6363 } 6364 6365 switch { 6366 default: 6367 var mv string 6368 t := decoder.StartEl 6369 _ = t 6370 val, err := decoder.Value() 6371 if err != nil { 6372 return err 6373 } 6374 if val == nil { 6375 break 6376 } 6377 { 6378 xtv := string(val) 6379 mv = xtv 6380 } 6381 sv = append(sv, mv) 6382 } 6383 *v = sv 6384 return nil 6385} 6386func awsRestxml_deserializeDocumentNestedPayload(v **types.NestedPayload, decoder smithyxml.NodeDecoder) error { 6387 if v == nil { 6388 return fmt.Errorf("unexpected nil of type %T", v) 6389 } 6390 var sv *types.NestedPayload 6391 if *v == nil { 6392 sv = &types.NestedPayload{} 6393 } else { 6394 sv = *v 6395 } 6396 6397 for { 6398 t, done, err := decoder.Token() 6399 if err != nil { 6400 return err 6401 } 6402 if done { 6403 break 6404 } 6405 originalDecoder := decoder 6406 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6407 switch { 6408 case strings.EqualFold("greeting", t.Name.Local): 6409 val, err := decoder.Value() 6410 if err != nil { 6411 return err 6412 } 6413 if val == nil { 6414 break 6415 } 6416 { 6417 xtv := string(val) 6418 sv.Greeting = ptr.String(xtv) 6419 } 6420 6421 case strings.EqualFold("name", t.Name.Local): 6422 val, err := decoder.Value() 6423 if err != nil { 6424 return err 6425 } 6426 if val == nil { 6427 break 6428 } 6429 { 6430 xtv := string(val) 6431 sv.Name = ptr.String(xtv) 6432 } 6433 6434 default: 6435 // Do nothing and ignore the unexpected tag element 6436 err = decoder.Decoder.Skip() 6437 if err != nil { 6438 return err 6439 } 6440 6441 } 6442 decoder = originalDecoder 6443 } 6444 *v = sv 6445 return nil 6446} 6447 6448func awsRestxml_deserializeDocumentPayloadWithXmlName(v **types.PayloadWithXmlName, decoder smithyxml.NodeDecoder) error { 6449 if v == nil { 6450 return fmt.Errorf("unexpected nil of type %T", v) 6451 } 6452 var sv *types.PayloadWithXmlName 6453 if *v == nil { 6454 sv = &types.PayloadWithXmlName{} 6455 } else { 6456 sv = *v 6457 } 6458 6459 for { 6460 t, done, err := decoder.Token() 6461 if err != nil { 6462 return err 6463 } 6464 if done { 6465 break 6466 } 6467 originalDecoder := decoder 6468 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6469 switch { 6470 case strings.EqualFold("name", t.Name.Local): 6471 val, err := decoder.Value() 6472 if err != nil { 6473 return err 6474 } 6475 if val == nil { 6476 break 6477 } 6478 { 6479 xtv := string(val) 6480 sv.Name = ptr.String(xtv) 6481 } 6482 6483 default: 6484 // Do nothing and ignore the unexpected tag element 6485 err = decoder.Decoder.Skip() 6486 if err != nil { 6487 return err 6488 } 6489 6490 } 6491 decoder = originalDecoder 6492 } 6493 *v = sv 6494 return nil 6495} 6496 6497func awsRestxml_deserializeDocumentPayloadWithXmlNamespace(v **types.PayloadWithXmlNamespace, decoder smithyxml.NodeDecoder) error { 6498 if v == nil { 6499 return fmt.Errorf("unexpected nil of type %T", v) 6500 } 6501 var sv *types.PayloadWithXmlNamespace 6502 if *v == nil { 6503 sv = &types.PayloadWithXmlNamespace{} 6504 } else { 6505 sv = *v 6506 } 6507 6508 for { 6509 t, done, err := decoder.Token() 6510 if err != nil { 6511 return err 6512 } 6513 if done { 6514 break 6515 } 6516 originalDecoder := decoder 6517 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6518 switch { 6519 case strings.EqualFold("name", t.Name.Local): 6520 val, err := decoder.Value() 6521 if err != nil { 6522 return err 6523 } 6524 if val == nil { 6525 break 6526 } 6527 { 6528 xtv := string(val) 6529 sv.Name = ptr.String(xtv) 6530 } 6531 6532 default: 6533 // Do nothing and ignore the unexpected tag element 6534 err = decoder.Decoder.Skip() 6535 if err != nil { 6536 return err 6537 } 6538 6539 } 6540 decoder = originalDecoder 6541 } 6542 *v = sv 6543 return nil 6544} 6545 6546func awsRestxml_deserializeDocumentPayloadWithXmlNamespaceAndPrefix(v **types.PayloadWithXmlNamespaceAndPrefix, decoder smithyxml.NodeDecoder) error { 6547 if v == nil { 6548 return fmt.Errorf("unexpected nil of type %T", v) 6549 } 6550 var sv *types.PayloadWithXmlNamespaceAndPrefix 6551 if *v == nil { 6552 sv = &types.PayloadWithXmlNamespaceAndPrefix{} 6553 } else { 6554 sv = *v 6555 } 6556 6557 for { 6558 t, done, err := decoder.Token() 6559 if err != nil { 6560 return err 6561 } 6562 if done { 6563 break 6564 } 6565 originalDecoder := decoder 6566 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6567 switch { 6568 case strings.EqualFold("name", t.Name.Local): 6569 val, err := decoder.Value() 6570 if err != nil { 6571 return err 6572 } 6573 if val == nil { 6574 break 6575 } 6576 { 6577 xtv := string(val) 6578 sv.Name = ptr.String(xtv) 6579 } 6580 6581 default: 6582 // Do nothing and ignore the unexpected tag element 6583 err = decoder.Decoder.Skip() 6584 if err != nil { 6585 return err 6586 } 6587 6588 } 6589 decoder = originalDecoder 6590 } 6591 *v = sv 6592 return nil 6593} 6594 6595func awsRestxml_deserializeDocumentRecursiveShapesInputOutputNested1(v **types.RecursiveShapesInputOutputNested1, decoder smithyxml.NodeDecoder) error { 6596 if v == nil { 6597 return fmt.Errorf("unexpected nil of type %T", v) 6598 } 6599 var sv *types.RecursiveShapesInputOutputNested1 6600 if *v == nil { 6601 sv = &types.RecursiveShapesInputOutputNested1{} 6602 } else { 6603 sv = *v 6604 } 6605 6606 for { 6607 t, done, err := decoder.Token() 6608 if err != nil { 6609 return err 6610 } 6611 if done { 6612 break 6613 } 6614 originalDecoder := decoder 6615 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6616 switch { 6617 case strings.EqualFold("foo", t.Name.Local): 6618 val, err := decoder.Value() 6619 if err != nil { 6620 return err 6621 } 6622 if val == nil { 6623 break 6624 } 6625 { 6626 xtv := string(val) 6627 sv.Foo = ptr.String(xtv) 6628 } 6629 6630 case strings.EqualFold("nested", t.Name.Local): 6631 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6632 if err := awsRestxml_deserializeDocumentRecursiveShapesInputOutputNested2(&sv.Nested, nodeDecoder); err != nil { 6633 return err 6634 } 6635 6636 default: 6637 // Do nothing and ignore the unexpected tag element 6638 err = decoder.Decoder.Skip() 6639 if err != nil { 6640 return err 6641 } 6642 6643 } 6644 decoder = originalDecoder 6645 } 6646 *v = sv 6647 return nil 6648} 6649 6650func awsRestxml_deserializeDocumentRecursiveShapesInputOutputNested2(v **types.RecursiveShapesInputOutputNested2, decoder smithyxml.NodeDecoder) error { 6651 if v == nil { 6652 return fmt.Errorf("unexpected nil of type %T", v) 6653 } 6654 var sv *types.RecursiveShapesInputOutputNested2 6655 if *v == nil { 6656 sv = &types.RecursiveShapesInputOutputNested2{} 6657 } else { 6658 sv = *v 6659 } 6660 6661 for { 6662 t, done, err := decoder.Token() 6663 if err != nil { 6664 return err 6665 } 6666 if done { 6667 break 6668 } 6669 originalDecoder := decoder 6670 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6671 switch { 6672 case strings.EqualFold("bar", t.Name.Local): 6673 val, err := decoder.Value() 6674 if err != nil { 6675 return err 6676 } 6677 if val == nil { 6678 break 6679 } 6680 { 6681 xtv := string(val) 6682 sv.Bar = ptr.String(xtv) 6683 } 6684 6685 case strings.EqualFold("recursiveMember", t.Name.Local): 6686 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6687 if err := awsRestxml_deserializeDocumentRecursiveShapesInputOutputNested1(&sv.RecursiveMember, nodeDecoder); err != nil { 6688 return err 6689 } 6690 6691 default: 6692 // Do nothing and ignore the unexpected tag element 6693 err = decoder.Decoder.Skip() 6694 if err != nil { 6695 return err 6696 } 6697 6698 } 6699 decoder = originalDecoder 6700 } 6701 *v = sv 6702 return nil 6703} 6704 6705func awsRestxml_deserializeDocumentRenamedListMembers(v *[]string, decoder smithyxml.NodeDecoder) error { 6706 if v == nil { 6707 return fmt.Errorf("unexpected nil of type %T", v) 6708 } 6709 var sv []string 6710 if *v == nil { 6711 sv = make([]string, 0) 6712 } else { 6713 sv = *v 6714 } 6715 6716 originalDecoder := decoder 6717 for { 6718 t, done, err := decoder.Token() 6719 if err != nil { 6720 return err 6721 } 6722 if done { 6723 break 6724 } 6725 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6726 decoder = memberDecoder 6727 switch { 6728 case strings.EqualFold("item", t.Name.Local): 6729 var col string 6730 val, err := decoder.Value() 6731 if err != nil { 6732 return err 6733 } 6734 if val == nil { 6735 break 6736 } 6737 { 6738 xtv := string(val) 6739 col = xtv 6740 } 6741 sv = append(sv, col) 6742 6743 default: 6744 err = decoder.Decoder.Skip() 6745 if err != nil { 6746 return err 6747 } 6748 6749 } 6750 decoder = originalDecoder 6751 } 6752 *v = sv 6753 return nil 6754} 6755 6756func awsRestxml_deserializeDocumentRenamedListMembersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 6757 var sv []string 6758 if *v == nil { 6759 sv = make([]string, 0) 6760 } else { 6761 sv = *v 6762 } 6763 6764 switch { 6765 default: 6766 var mv string 6767 t := decoder.StartEl 6768 _ = t 6769 val, err := decoder.Value() 6770 if err != nil { 6771 return err 6772 } 6773 if val == nil { 6774 break 6775 } 6776 { 6777 xtv := string(val) 6778 mv = xtv 6779 } 6780 sv = append(sv, mv) 6781 } 6782 *v = sv 6783 return nil 6784} 6785func awsRestxml_deserializeDocumentStructureList(v *[]types.StructureListMember, decoder smithyxml.NodeDecoder) error { 6786 if v == nil { 6787 return fmt.Errorf("unexpected nil of type %T", v) 6788 } 6789 var sv []types.StructureListMember 6790 if *v == nil { 6791 sv = make([]types.StructureListMember, 0) 6792 } else { 6793 sv = *v 6794 } 6795 6796 originalDecoder := decoder 6797 for { 6798 t, done, err := decoder.Token() 6799 if err != nil { 6800 return err 6801 } 6802 if done { 6803 break 6804 } 6805 switch { 6806 case strings.EqualFold("item", t.Name.Local): 6807 var col types.StructureListMember 6808 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6809 destAddr := &col 6810 if err := awsRestxml_deserializeDocumentStructureListMember(&destAddr, nodeDecoder); err != nil { 6811 return err 6812 } 6813 col = *destAddr 6814 sv = append(sv, col) 6815 6816 default: 6817 err = decoder.Decoder.Skip() 6818 if err != nil { 6819 return err 6820 } 6821 6822 } 6823 decoder = originalDecoder 6824 } 6825 *v = sv 6826 return nil 6827} 6828 6829func awsRestxml_deserializeDocumentStructureListUnwrapped(v *[]types.StructureListMember, decoder smithyxml.NodeDecoder) error { 6830 var sv []types.StructureListMember 6831 if *v == nil { 6832 sv = make([]types.StructureListMember, 0) 6833 } else { 6834 sv = *v 6835 } 6836 6837 switch { 6838 default: 6839 var mv types.StructureListMember 6840 t := decoder.StartEl 6841 _ = t 6842 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6843 destAddr := &mv 6844 if err := awsRestxml_deserializeDocumentStructureListMember(&destAddr, nodeDecoder); err != nil { 6845 return err 6846 } 6847 mv = *destAddr 6848 sv = append(sv, mv) 6849 } 6850 *v = sv 6851 return nil 6852} 6853func awsRestxml_deserializeDocumentStructureListMember(v **types.StructureListMember, decoder smithyxml.NodeDecoder) error { 6854 if v == nil { 6855 return fmt.Errorf("unexpected nil of type %T", v) 6856 } 6857 var sv *types.StructureListMember 6858 if *v == nil { 6859 sv = &types.StructureListMember{} 6860 } else { 6861 sv = *v 6862 } 6863 6864 for { 6865 t, done, err := decoder.Token() 6866 if err != nil { 6867 return err 6868 } 6869 if done { 6870 break 6871 } 6872 originalDecoder := decoder 6873 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6874 switch { 6875 case strings.EqualFold("value", t.Name.Local): 6876 val, err := decoder.Value() 6877 if err != nil { 6878 return err 6879 } 6880 if val == nil { 6881 break 6882 } 6883 { 6884 xtv := string(val) 6885 sv.A = ptr.String(xtv) 6886 } 6887 6888 case strings.EqualFold("other", t.Name.Local): 6889 val, err := decoder.Value() 6890 if err != nil { 6891 return err 6892 } 6893 if val == nil { 6894 break 6895 } 6896 { 6897 xtv := string(val) 6898 sv.B = ptr.String(xtv) 6899 } 6900 6901 default: 6902 // Do nothing and ignore the unexpected tag element 6903 err = decoder.Decoder.Skip() 6904 if err != nil { 6905 return err 6906 } 6907 6908 } 6909 decoder = originalDecoder 6910 } 6911 *v = sv 6912 return nil 6913} 6914 6915func awsRestxml_deserializeDocumentXmlAttributesInputOutput(v **types.XmlAttributesInputOutput, decoder smithyxml.NodeDecoder) error { 6916 if v == nil { 6917 return fmt.Errorf("unexpected nil of type %T", v) 6918 } 6919 var sv *types.XmlAttributesInputOutput 6920 if *v == nil { 6921 sv = &types.XmlAttributesInputOutput{} 6922 } else { 6923 sv = *v 6924 } 6925 6926 for _, attr := range decoder.StartEl.Attr { 6927 name := attr.Name.Local 6928 if len(attr.Name.Space) != 0 { 6929 name = attr.Name.Space + `:` + attr.Name.Local 6930 } 6931 switch { 6932 case strings.EqualFold("test", name): 6933 val := []byte(attr.Value) 6934 { 6935 xtv := string(val) 6936 sv.Attr = ptr.String(xtv) 6937 } 6938 6939 } 6940 } 6941 for { 6942 t, done, err := decoder.Token() 6943 if err != nil { 6944 return err 6945 } 6946 if done { 6947 break 6948 } 6949 originalDecoder := decoder 6950 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6951 switch { 6952 case strings.EqualFold("foo", t.Name.Local): 6953 val, err := decoder.Value() 6954 if err != nil { 6955 return err 6956 } 6957 if val == nil { 6958 break 6959 } 6960 { 6961 xtv := string(val) 6962 sv.Foo = ptr.String(xtv) 6963 } 6964 6965 default: 6966 // Do nothing and ignore the unexpected tag element 6967 err = decoder.Decoder.Skip() 6968 if err != nil { 6969 return err 6970 } 6971 6972 } 6973 decoder = originalDecoder 6974 } 6975 *v = sv 6976 return nil 6977} 6978 6979func awsRestxml_deserializeDocumentXmlMapsInputOutputMap(v *map[string]types.GreetingStruct, decoder smithyxml.NodeDecoder) error { 6980 if v == nil { 6981 return fmt.Errorf("unexpected nil of type %T", v) 6982 } 6983 var sv map[string]types.GreetingStruct 6984 if *v == nil { 6985 sv = make(map[string]types.GreetingStruct, 0) 6986 } else { 6987 sv = *v 6988 } 6989 6990 for { 6991 t, done, err := decoder.Token() 6992 if err != nil { 6993 return err 6994 } 6995 if done { 6996 break 6997 } 6998 switch { 6999 case strings.EqualFold("entry", t.Name.Local): 7000 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7001 if err := awsRestxml_deserializeDocumentXmlMapsInputOutputMapUnwrapped(&sv, entryDecoder); err != nil { 7002 return err 7003 } 7004 7005 default: 7006 err = decoder.Decoder.Skip() 7007 if err != nil { 7008 return err 7009 } 7010 7011 } 7012 } 7013 *v = sv 7014 return nil 7015} 7016 7017func awsRestxml_deserializeDocumentXmlMapsInputOutputMapUnwrapped(v *map[string]types.GreetingStruct, decoder smithyxml.NodeDecoder) error { 7018 var sv map[string]types.GreetingStruct 7019 if *v == nil { 7020 sv = make(map[string]types.GreetingStruct, 0) 7021 } else { 7022 sv = *v 7023 } 7024 7025 var ek string 7026 var ev types.GreetingStruct 7027 for { 7028 t, done, err := decoder.Token() 7029 if err != nil { 7030 return err 7031 } 7032 if done { 7033 sv[ek] = ev 7034 break 7035 } 7036 originalDecoder := decoder 7037 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7038 switch { 7039 case strings.EqualFold("key", t.Name.Local): 7040 val, err := decoder.Value() 7041 if err != nil { 7042 return err 7043 } 7044 if val == nil { 7045 break 7046 } 7047 { 7048 xtv := string(val) 7049 ek = xtv 7050 } 7051 7052 case strings.EqualFold("value", t.Name.Local): 7053 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7054 mapVar := ev 7055 destAddr := &mapVar 7056 if err := awsRestxml_deserializeDocumentGreetingStruct(&destAddr, nodeDecoder); err != nil { 7057 return err 7058 } 7059 ev = *destAddr 7060 7061 default: 7062 err = decoder.Decoder.Skip() 7063 if err != nil { 7064 return err 7065 } 7066 7067 } 7068 decoder = originalDecoder 7069 } 7070 *v = sv 7071 return nil 7072} 7073func awsRestxml_deserializeDocumentXmlMapsXmlNameInputOutputMap(v *map[string]types.GreetingStruct, decoder smithyxml.NodeDecoder) error { 7074 if v == nil { 7075 return fmt.Errorf("unexpected nil of type %T", v) 7076 } 7077 var sv map[string]types.GreetingStruct 7078 if *v == nil { 7079 sv = make(map[string]types.GreetingStruct, 0) 7080 } else { 7081 sv = *v 7082 } 7083 7084 for { 7085 t, done, err := decoder.Token() 7086 if err != nil { 7087 return err 7088 } 7089 if done { 7090 break 7091 } 7092 switch { 7093 case strings.EqualFold("entry", t.Name.Local): 7094 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7095 if err := awsRestxml_deserializeDocumentXmlMapsXmlNameInputOutputMapUnwrapped(&sv, entryDecoder); err != nil { 7096 return err 7097 } 7098 7099 default: 7100 err = decoder.Decoder.Skip() 7101 if err != nil { 7102 return err 7103 } 7104 7105 } 7106 } 7107 *v = sv 7108 return nil 7109} 7110 7111func awsRestxml_deserializeDocumentXmlMapsXmlNameInputOutputMapUnwrapped(v *map[string]types.GreetingStruct, decoder smithyxml.NodeDecoder) error { 7112 var sv map[string]types.GreetingStruct 7113 if *v == nil { 7114 sv = make(map[string]types.GreetingStruct, 0) 7115 } else { 7116 sv = *v 7117 } 7118 7119 var ek string 7120 var ev types.GreetingStruct 7121 for { 7122 t, done, err := decoder.Token() 7123 if err != nil { 7124 return err 7125 } 7126 if done { 7127 sv[ek] = ev 7128 break 7129 } 7130 originalDecoder := decoder 7131 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7132 switch { 7133 case strings.EqualFold("Attribute", t.Name.Local): 7134 val, err := decoder.Value() 7135 if err != nil { 7136 return err 7137 } 7138 if val == nil { 7139 break 7140 } 7141 { 7142 xtv := string(val) 7143 ek = xtv 7144 } 7145 7146 case strings.EqualFold("Setting", t.Name.Local): 7147 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7148 mapVar := ev 7149 destAddr := &mapVar 7150 if err := awsRestxml_deserializeDocumentGreetingStruct(&destAddr, nodeDecoder); err != nil { 7151 return err 7152 } 7153 ev = *destAddr 7154 7155 default: 7156 err = decoder.Decoder.Skip() 7157 if err != nil { 7158 return err 7159 } 7160 7161 } 7162 decoder = originalDecoder 7163 } 7164 *v = sv 7165 return nil 7166} 7167func awsRestxml_deserializeDocumentXmlNamespacedList(v *[]string, decoder smithyxml.NodeDecoder) error { 7168 if v == nil { 7169 return fmt.Errorf("unexpected nil of type %T", v) 7170 } 7171 var sv []string 7172 if *v == nil { 7173 sv = make([]string, 0) 7174 } else { 7175 sv = *v 7176 } 7177 7178 originalDecoder := decoder 7179 for { 7180 t, done, err := decoder.Token() 7181 if err != nil { 7182 return err 7183 } 7184 if done { 7185 break 7186 } 7187 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7188 decoder = memberDecoder 7189 switch { 7190 case strings.EqualFold("member", t.Name.Local): 7191 var col string 7192 val, err := decoder.Value() 7193 if err != nil { 7194 return err 7195 } 7196 if val == nil { 7197 break 7198 } 7199 { 7200 xtv := string(val) 7201 col = xtv 7202 } 7203 sv = append(sv, col) 7204 7205 default: 7206 err = decoder.Decoder.Skip() 7207 if err != nil { 7208 return err 7209 } 7210 7211 } 7212 decoder = originalDecoder 7213 } 7214 *v = sv 7215 return nil 7216} 7217 7218func awsRestxml_deserializeDocumentXmlNamespacedListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 7219 var sv []string 7220 if *v == nil { 7221 sv = make([]string, 0) 7222 } else { 7223 sv = *v 7224 } 7225 7226 switch { 7227 default: 7228 var mv string 7229 t := decoder.StartEl 7230 _ = t 7231 val, err := decoder.Value() 7232 if err != nil { 7233 return err 7234 } 7235 if val == nil { 7236 break 7237 } 7238 { 7239 xtv := string(val) 7240 mv = xtv 7241 } 7242 sv = append(sv, mv) 7243 } 7244 *v = sv 7245 return nil 7246} 7247func awsRestxml_deserializeDocumentXmlNamespaceNested(v **types.XmlNamespaceNested, decoder smithyxml.NodeDecoder) error { 7248 if v == nil { 7249 return fmt.Errorf("unexpected nil of type %T", v) 7250 } 7251 var sv *types.XmlNamespaceNested 7252 if *v == nil { 7253 sv = &types.XmlNamespaceNested{} 7254 } else { 7255 sv = *v 7256 } 7257 7258 for { 7259 t, done, err := decoder.Token() 7260 if err != nil { 7261 return err 7262 } 7263 if done { 7264 break 7265 } 7266 originalDecoder := decoder 7267 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7268 switch { 7269 case strings.EqualFold("foo", t.Name.Local): 7270 val, err := decoder.Value() 7271 if err != nil { 7272 return err 7273 } 7274 if val == nil { 7275 break 7276 } 7277 { 7278 xtv := string(val) 7279 sv.Foo = ptr.String(xtv) 7280 } 7281 7282 case strings.EqualFold("values", t.Name.Local): 7283 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7284 if err := awsRestxml_deserializeDocumentXmlNamespacedList(&sv.Values, nodeDecoder); err != nil { 7285 return err 7286 } 7287 7288 default: 7289 // Do nothing and ignore the unexpected tag element 7290 err = decoder.Decoder.Skip() 7291 if err != nil { 7292 return err 7293 } 7294 7295 } 7296 decoder = originalDecoder 7297 } 7298 *v = sv 7299 return nil 7300} 7301 7302func awsRestxml_deserializeDocumentXmlNestedUnionStruct(v **types.XmlNestedUnionStruct, decoder smithyxml.NodeDecoder) error { 7303 if v == nil { 7304 return fmt.Errorf("unexpected nil of type %T", v) 7305 } 7306 var sv *types.XmlNestedUnionStruct 7307 if *v == nil { 7308 sv = &types.XmlNestedUnionStruct{} 7309 } else { 7310 sv = *v 7311 } 7312 7313 for { 7314 t, done, err := decoder.Token() 7315 if err != nil { 7316 return err 7317 } 7318 if done { 7319 break 7320 } 7321 originalDecoder := decoder 7322 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7323 switch { 7324 case strings.EqualFold("booleanValue", t.Name.Local): 7325 val, err := decoder.Value() 7326 if err != nil { 7327 return err 7328 } 7329 if val == nil { 7330 break 7331 } 7332 { 7333 xtv, err := strconv.ParseBool(string(val)) 7334 if err != nil { 7335 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 7336 } 7337 sv.BooleanValue = ptr.Bool(xtv) 7338 } 7339 7340 case strings.EqualFold("byteValue", t.Name.Local): 7341 val, err := decoder.Value() 7342 if err != nil { 7343 return err 7344 } 7345 if val == nil { 7346 break 7347 } 7348 { 7349 xtv := string(val) 7350 i64, err := strconv.ParseInt(xtv, 10, 64) 7351 if err != nil { 7352 return err 7353 } 7354 sv.ByteValue = ptr.Int8(int8(i64)) 7355 } 7356 7357 case strings.EqualFold("doubleValue", t.Name.Local): 7358 val, err := decoder.Value() 7359 if err != nil { 7360 return err 7361 } 7362 if val == nil { 7363 break 7364 } 7365 { 7366 xtv := string(val) 7367 f64, err := strconv.ParseFloat(xtv, 64) 7368 if err != nil { 7369 return err 7370 } 7371 sv.DoubleValue = ptr.Float64(f64) 7372 } 7373 7374 case strings.EqualFold("floatValue", t.Name.Local): 7375 val, err := decoder.Value() 7376 if err != nil { 7377 return err 7378 } 7379 if val == nil { 7380 break 7381 } 7382 { 7383 xtv := string(val) 7384 f64, err := strconv.ParseFloat(xtv, 64) 7385 if err != nil { 7386 return err 7387 } 7388 sv.FloatValue = ptr.Float32(float32(f64)) 7389 } 7390 7391 case strings.EqualFold("integerValue", t.Name.Local): 7392 val, err := decoder.Value() 7393 if err != nil { 7394 return err 7395 } 7396 if val == nil { 7397 break 7398 } 7399 { 7400 xtv := string(val) 7401 i64, err := strconv.ParseInt(xtv, 10, 64) 7402 if err != nil { 7403 return err 7404 } 7405 sv.IntegerValue = ptr.Int32(int32(i64)) 7406 } 7407 7408 case strings.EqualFold("longValue", t.Name.Local): 7409 val, err := decoder.Value() 7410 if err != nil { 7411 return err 7412 } 7413 if val == nil { 7414 break 7415 } 7416 { 7417 xtv := string(val) 7418 i64, err := strconv.ParseInt(xtv, 10, 64) 7419 if err != nil { 7420 return err 7421 } 7422 sv.LongValue = ptr.Int64(i64) 7423 } 7424 7425 case strings.EqualFold("shortValue", t.Name.Local): 7426 val, err := decoder.Value() 7427 if err != nil { 7428 return err 7429 } 7430 if val == nil { 7431 break 7432 } 7433 { 7434 xtv := string(val) 7435 i64, err := strconv.ParseInt(xtv, 10, 64) 7436 if err != nil { 7437 return err 7438 } 7439 sv.ShortValue = ptr.Int16(int16(i64)) 7440 } 7441 7442 case strings.EqualFold("stringValue", t.Name.Local): 7443 val, err := decoder.Value() 7444 if err != nil { 7445 return err 7446 } 7447 if val == nil { 7448 break 7449 } 7450 { 7451 xtv := string(val) 7452 sv.StringValue = ptr.String(xtv) 7453 } 7454 7455 default: 7456 // Do nothing and ignore the unexpected tag element 7457 err = decoder.Decoder.Skip() 7458 if err != nil { 7459 return err 7460 } 7461 7462 } 7463 decoder = originalDecoder 7464 } 7465 *v = sv 7466 return nil 7467} 7468 7469func awsRestxml_deserializeDocumentXmlUnionShape(v *types.XmlUnionShape, decoder smithyxml.NodeDecoder) error { 7470 if v == nil { 7471 return fmt.Errorf("unexpected nil of type %T", v) 7472 } 7473 var uv types.XmlUnionShape 7474 var memberFound bool 7475 for { 7476 t, done, err := decoder.Token() 7477 if err != nil { 7478 return err 7479 } 7480 if done { 7481 break 7482 } 7483 if memberFound { 7484 if err = decoder.Decoder.Skip(); err != nil { 7485 return err 7486 } 7487 } 7488 originalDecoder := decoder 7489 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7490 switch { 7491 case strings.EqualFold("booleanValue", t.Name.Local): 7492 var mv bool 7493 val, err := decoder.Value() 7494 if err != nil { 7495 return err 7496 } 7497 if val == nil { 7498 break 7499 } 7500 { 7501 xtv, err := strconv.ParseBool(string(val)) 7502 if err != nil { 7503 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 7504 } 7505 mv = xtv 7506 } 7507 uv = &types.XmlUnionShapeMemberBooleanValue{Value: mv} 7508 memberFound = true 7509 7510 case strings.EqualFold("byteValue", t.Name.Local): 7511 var mv int8 7512 val, err := decoder.Value() 7513 if err != nil { 7514 return err 7515 } 7516 if val == nil { 7517 break 7518 } 7519 { 7520 xtv := string(val) 7521 i64, err := strconv.ParseInt(xtv, 10, 64) 7522 if err != nil { 7523 return err 7524 } 7525 mv = int8(i64) 7526 } 7527 uv = &types.XmlUnionShapeMemberByteValue{Value: mv} 7528 memberFound = true 7529 7530 case strings.EqualFold("doubleValue", t.Name.Local): 7531 var mv float64 7532 val, err := decoder.Value() 7533 if err != nil { 7534 return err 7535 } 7536 if val == nil { 7537 break 7538 } 7539 { 7540 xtv := string(val) 7541 f64, err := strconv.ParseFloat(xtv, 64) 7542 if err != nil { 7543 return err 7544 } 7545 mv = f64 7546 } 7547 uv = &types.XmlUnionShapeMemberDoubleValue{Value: mv} 7548 memberFound = true 7549 7550 case strings.EqualFold("floatValue", t.Name.Local): 7551 var mv float32 7552 val, err := decoder.Value() 7553 if err != nil { 7554 return err 7555 } 7556 if val == nil { 7557 break 7558 } 7559 { 7560 xtv := string(val) 7561 f64, err := strconv.ParseFloat(xtv, 64) 7562 if err != nil { 7563 return err 7564 } 7565 mv = float32(f64) 7566 } 7567 uv = &types.XmlUnionShapeMemberFloatValue{Value: mv} 7568 memberFound = true 7569 7570 case strings.EqualFold("integerValue", t.Name.Local): 7571 var mv int32 7572 val, err := decoder.Value() 7573 if err != nil { 7574 return err 7575 } 7576 if val == nil { 7577 break 7578 } 7579 { 7580 xtv := string(val) 7581 i64, err := strconv.ParseInt(xtv, 10, 64) 7582 if err != nil { 7583 return err 7584 } 7585 mv = int32(i64) 7586 } 7587 uv = &types.XmlUnionShapeMemberIntegerValue{Value: mv} 7588 memberFound = true 7589 7590 case strings.EqualFold("longValue", t.Name.Local): 7591 var mv int64 7592 val, err := decoder.Value() 7593 if err != nil { 7594 return err 7595 } 7596 if val == nil { 7597 break 7598 } 7599 { 7600 xtv := string(val) 7601 i64, err := strconv.ParseInt(xtv, 10, 64) 7602 if err != nil { 7603 return err 7604 } 7605 mv = i64 7606 } 7607 uv = &types.XmlUnionShapeMemberLongValue{Value: mv} 7608 memberFound = true 7609 7610 case strings.EqualFold("shortValue", t.Name.Local): 7611 var mv int16 7612 val, err := decoder.Value() 7613 if err != nil { 7614 return err 7615 } 7616 if val == nil { 7617 break 7618 } 7619 { 7620 xtv := string(val) 7621 i64, err := strconv.ParseInt(xtv, 10, 64) 7622 if err != nil { 7623 return err 7624 } 7625 mv = int16(i64) 7626 } 7627 uv = &types.XmlUnionShapeMemberShortValue{Value: mv} 7628 memberFound = true 7629 7630 case strings.EqualFold("stringValue", t.Name.Local): 7631 var mv string 7632 val, err := decoder.Value() 7633 if err != nil { 7634 return err 7635 } 7636 if val == nil { 7637 break 7638 } 7639 { 7640 xtv := string(val) 7641 mv = xtv 7642 } 7643 uv = &types.XmlUnionShapeMemberStringValue{Value: mv} 7644 memberFound = true 7645 7646 case strings.EqualFold("structValue", t.Name.Local): 7647 var mv types.XmlNestedUnionStruct 7648 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7649 destAddr := &mv 7650 if err := awsRestxml_deserializeDocumentXmlNestedUnionStruct(&destAddr, nodeDecoder); err != nil { 7651 return err 7652 } 7653 mv = *destAddr 7654 uv = &types.XmlUnionShapeMemberStructValue{Value: mv} 7655 memberFound = true 7656 7657 case strings.EqualFold("unionValue", t.Name.Local): 7658 var mv types.XmlUnionShape 7659 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7660 if err := awsRestxml_deserializeDocumentXmlUnionShape(&mv, nodeDecoder); err != nil { 7661 return err 7662 } 7663 uv = &types.XmlUnionShapeMemberUnionValue{Value: mv} 7664 memberFound = true 7665 7666 default: 7667 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 7668 memberFound = true 7669 7670 } 7671 decoder = originalDecoder 7672 } 7673 *v = uv 7674 return nil 7675} 7676 7677func awsRestxml_deserializeDocumentBooleanList(v *[]bool, decoder smithyxml.NodeDecoder) error { 7678 if v == nil { 7679 return fmt.Errorf("unexpected nil of type %T", v) 7680 } 7681 var sv []bool 7682 if *v == nil { 7683 sv = make([]bool, 0) 7684 } else { 7685 sv = *v 7686 } 7687 7688 originalDecoder := decoder 7689 for { 7690 t, done, err := decoder.Token() 7691 if err != nil { 7692 return err 7693 } 7694 if done { 7695 break 7696 } 7697 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7698 decoder = memberDecoder 7699 switch { 7700 case strings.EqualFold("member", t.Name.Local): 7701 var col bool 7702 val, err := decoder.Value() 7703 if err != nil { 7704 return err 7705 } 7706 if val == nil { 7707 break 7708 } 7709 { 7710 xtv, err := strconv.ParseBool(string(val)) 7711 if err != nil { 7712 return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", val) 7713 } 7714 col = xtv 7715 } 7716 sv = append(sv, col) 7717 7718 default: 7719 err = decoder.Decoder.Skip() 7720 if err != nil { 7721 return err 7722 } 7723 7724 } 7725 decoder = originalDecoder 7726 } 7727 *v = sv 7728 return nil 7729} 7730 7731func awsRestxml_deserializeDocumentBooleanListUnwrapped(v *[]bool, decoder smithyxml.NodeDecoder) error { 7732 var sv []bool 7733 if *v == nil { 7734 sv = make([]bool, 0) 7735 } else { 7736 sv = *v 7737 } 7738 7739 switch { 7740 default: 7741 var mv bool 7742 t := decoder.StartEl 7743 _ = t 7744 val, err := decoder.Value() 7745 if err != nil { 7746 return err 7747 } 7748 if val == nil { 7749 break 7750 } 7751 { 7752 xtv, err := strconv.ParseBool(string(val)) 7753 if err != nil { 7754 return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", val) 7755 } 7756 mv = xtv 7757 } 7758 sv = append(sv, mv) 7759 } 7760 *v = sv 7761 return nil 7762} 7763func awsRestxml_deserializeDocumentFooEnumList(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 7764 if v == nil { 7765 return fmt.Errorf("unexpected nil of type %T", v) 7766 } 7767 var sv []types.FooEnum 7768 if *v == nil { 7769 sv = make([]types.FooEnum, 0) 7770 } else { 7771 sv = *v 7772 } 7773 7774 originalDecoder := decoder 7775 for { 7776 t, done, err := decoder.Token() 7777 if err != nil { 7778 return err 7779 } 7780 if done { 7781 break 7782 } 7783 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7784 decoder = memberDecoder 7785 switch { 7786 case strings.EqualFold("member", t.Name.Local): 7787 var col types.FooEnum 7788 val, err := decoder.Value() 7789 if err != nil { 7790 return err 7791 } 7792 if val == nil { 7793 break 7794 } 7795 { 7796 xtv := string(val) 7797 col = types.FooEnum(xtv) 7798 } 7799 sv = append(sv, col) 7800 7801 default: 7802 err = decoder.Decoder.Skip() 7803 if err != nil { 7804 return err 7805 } 7806 7807 } 7808 decoder = originalDecoder 7809 } 7810 *v = sv 7811 return nil 7812} 7813 7814func awsRestxml_deserializeDocumentFooEnumListUnwrapped(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 7815 var sv []types.FooEnum 7816 if *v == nil { 7817 sv = make([]types.FooEnum, 0) 7818 } else { 7819 sv = *v 7820 } 7821 7822 switch { 7823 default: 7824 var mv types.FooEnum 7825 t := decoder.StartEl 7826 _ = t 7827 val, err := decoder.Value() 7828 if err != nil { 7829 return err 7830 } 7831 if val == nil { 7832 break 7833 } 7834 { 7835 xtv := string(val) 7836 mv = types.FooEnum(xtv) 7837 } 7838 sv = append(sv, mv) 7839 } 7840 *v = sv 7841 return nil 7842} 7843func awsRestxml_deserializeDocumentFooEnumMap(v *map[string]types.FooEnum, decoder smithyxml.NodeDecoder) error { 7844 if v == nil { 7845 return fmt.Errorf("unexpected nil of type %T", v) 7846 } 7847 var sv map[string]types.FooEnum 7848 if *v == nil { 7849 sv = make(map[string]types.FooEnum, 0) 7850 } else { 7851 sv = *v 7852 } 7853 7854 for { 7855 t, done, err := decoder.Token() 7856 if err != nil { 7857 return err 7858 } 7859 if done { 7860 break 7861 } 7862 switch { 7863 case strings.EqualFold("entry", t.Name.Local): 7864 entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7865 if err := awsRestxml_deserializeDocumentFooEnumMapUnwrapped(&sv, entryDecoder); err != nil { 7866 return err 7867 } 7868 7869 default: 7870 err = decoder.Decoder.Skip() 7871 if err != nil { 7872 return err 7873 } 7874 7875 } 7876 } 7877 *v = sv 7878 return nil 7879} 7880 7881func awsRestxml_deserializeDocumentFooEnumMapUnwrapped(v *map[string]types.FooEnum, decoder smithyxml.NodeDecoder) error { 7882 var sv map[string]types.FooEnum 7883 if *v == nil { 7884 sv = make(map[string]types.FooEnum, 0) 7885 } else { 7886 sv = *v 7887 } 7888 7889 var ek string 7890 var ev types.FooEnum 7891 for { 7892 t, done, err := decoder.Token() 7893 if err != nil { 7894 return err 7895 } 7896 if done { 7897 sv[ek] = ev 7898 break 7899 } 7900 originalDecoder := decoder 7901 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7902 switch { 7903 case strings.EqualFold("key", t.Name.Local): 7904 val, err := decoder.Value() 7905 if err != nil { 7906 return err 7907 } 7908 if val == nil { 7909 break 7910 } 7911 { 7912 xtv := string(val) 7913 ek = xtv 7914 } 7915 7916 case strings.EqualFold("value", t.Name.Local): 7917 val, err := decoder.Value() 7918 if err != nil { 7919 return err 7920 } 7921 if val == nil { 7922 break 7923 } 7924 { 7925 xtv := string(val) 7926 ev = types.FooEnum(xtv) 7927 } 7928 7929 default: 7930 err = decoder.Decoder.Skip() 7931 if err != nil { 7932 return err 7933 } 7934 7935 } 7936 decoder = originalDecoder 7937 } 7938 *v = sv 7939 return nil 7940} 7941func awsRestxml_deserializeDocumentFooEnumSet(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 7942 if v == nil { 7943 return fmt.Errorf("unexpected nil of type %T", v) 7944 } 7945 var sv []types.FooEnum 7946 if *v == nil { 7947 sv = make([]types.FooEnum, 0) 7948 } else { 7949 sv = *v 7950 } 7951 7952 originalDecoder := decoder 7953 for { 7954 t, done, err := decoder.Token() 7955 if err != nil { 7956 return err 7957 } 7958 if done { 7959 break 7960 } 7961 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7962 decoder = memberDecoder 7963 switch { 7964 case strings.EqualFold("member", t.Name.Local): 7965 var col types.FooEnum 7966 val, err := decoder.Value() 7967 if err != nil { 7968 return err 7969 } 7970 if val == nil { 7971 break 7972 } 7973 { 7974 xtv := string(val) 7975 col = types.FooEnum(xtv) 7976 } 7977 sv = append(sv, col) 7978 7979 default: 7980 err = decoder.Decoder.Skip() 7981 if err != nil { 7982 return err 7983 } 7984 7985 } 7986 decoder = originalDecoder 7987 } 7988 *v = sv 7989 return nil 7990} 7991 7992func awsRestxml_deserializeDocumentFooEnumSetUnwrapped(v *[]types.FooEnum, decoder smithyxml.NodeDecoder) error { 7993 var sv []types.FooEnum 7994 if *v == nil { 7995 sv = make([]types.FooEnum, 0) 7996 } else { 7997 sv = *v 7998 } 7999 8000 switch { 8001 default: 8002 var mv types.FooEnum 8003 t := decoder.StartEl 8004 _ = t 8005 val, err := decoder.Value() 8006 if err != nil { 8007 return err 8008 } 8009 if val == nil { 8010 break 8011 } 8012 { 8013 xtv := string(val) 8014 mv = types.FooEnum(xtv) 8015 } 8016 sv = append(sv, mv) 8017 } 8018 *v = sv 8019 return nil 8020} 8021func awsRestxml_deserializeDocumentGreetingStruct(v **types.GreetingStruct, decoder smithyxml.NodeDecoder) error { 8022 if v == nil { 8023 return fmt.Errorf("unexpected nil of type %T", v) 8024 } 8025 var sv *types.GreetingStruct 8026 if *v == nil { 8027 sv = &types.GreetingStruct{} 8028 } else { 8029 sv = *v 8030 } 8031 8032 for { 8033 t, done, err := decoder.Token() 8034 if err != nil { 8035 return err 8036 } 8037 if done { 8038 break 8039 } 8040 originalDecoder := decoder 8041 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8042 switch { 8043 case strings.EqualFold("hi", t.Name.Local): 8044 val, err := decoder.Value() 8045 if err != nil { 8046 return err 8047 } 8048 if val == nil { 8049 break 8050 } 8051 { 8052 xtv := string(val) 8053 sv.Hi = ptr.String(xtv) 8054 } 8055 8056 default: 8057 // Do nothing and ignore the unexpected tag element 8058 err = decoder.Decoder.Skip() 8059 if err != nil { 8060 return err 8061 } 8062 8063 } 8064 decoder = originalDecoder 8065 } 8066 *v = sv 8067 return nil 8068} 8069 8070func awsRestxml_deserializeDocumentIntegerList(v *[]int32, decoder smithyxml.NodeDecoder) error { 8071 if v == nil { 8072 return fmt.Errorf("unexpected nil of type %T", v) 8073 } 8074 var sv []int32 8075 if *v == nil { 8076 sv = make([]int32, 0) 8077 } else { 8078 sv = *v 8079 } 8080 8081 originalDecoder := decoder 8082 for { 8083 t, done, err := decoder.Token() 8084 if err != nil { 8085 return err 8086 } 8087 if done { 8088 break 8089 } 8090 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8091 decoder = memberDecoder 8092 switch { 8093 case strings.EqualFold("member", t.Name.Local): 8094 var col int32 8095 val, err := decoder.Value() 8096 if err != nil { 8097 return err 8098 } 8099 if val == nil { 8100 break 8101 } 8102 { 8103 xtv := string(val) 8104 i64, err := strconv.ParseInt(xtv, 10, 64) 8105 if err != nil { 8106 return err 8107 } 8108 col = int32(i64) 8109 } 8110 sv = append(sv, col) 8111 8112 default: 8113 err = decoder.Decoder.Skip() 8114 if err != nil { 8115 return err 8116 } 8117 8118 } 8119 decoder = originalDecoder 8120 } 8121 *v = sv 8122 return nil 8123} 8124 8125func awsRestxml_deserializeDocumentIntegerListUnwrapped(v *[]int32, decoder smithyxml.NodeDecoder) error { 8126 var sv []int32 8127 if *v == nil { 8128 sv = make([]int32, 0) 8129 } else { 8130 sv = *v 8131 } 8132 8133 switch { 8134 default: 8135 var mv int32 8136 t := decoder.StartEl 8137 _ = t 8138 val, err := decoder.Value() 8139 if err != nil { 8140 return err 8141 } 8142 if val == nil { 8143 break 8144 } 8145 { 8146 xtv := string(val) 8147 i64, err := strconv.ParseInt(xtv, 10, 64) 8148 if err != nil { 8149 return err 8150 } 8151 mv = int32(i64) 8152 } 8153 sv = append(sv, mv) 8154 } 8155 *v = sv 8156 return nil 8157} 8158func awsRestxml_deserializeDocumentNestedStringList(v *[][]string, decoder smithyxml.NodeDecoder) error { 8159 if v == nil { 8160 return fmt.Errorf("unexpected nil of type %T", v) 8161 } 8162 var sv [][]string 8163 if *v == nil { 8164 sv = make([][]string, 0) 8165 } else { 8166 sv = *v 8167 } 8168 8169 originalDecoder := decoder 8170 for { 8171 t, done, err := decoder.Token() 8172 if err != nil { 8173 return err 8174 } 8175 if done { 8176 break 8177 } 8178 switch { 8179 case strings.EqualFold("member", t.Name.Local): 8180 var col []string 8181 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8182 if err := awsRestxml_deserializeDocumentStringList(&col, nodeDecoder); err != nil { 8183 return err 8184 } 8185 sv = append(sv, col) 8186 8187 default: 8188 err = decoder.Decoder.Skip() 8189 if err != nil { 8190 return err 8191 } 8192 8193 } 8194 decoder = originalDecoder 8195 } 8196 *v = sv 8197 return nil 8198} 8199 8200func awsRestxml_deserializeDocumentNestedStringListUnwrapped(v *[][]string, decoder smithyxml.NodeDecoder) error { 8201 var sv [][]string 8202 if *v == nil { 8203 sv = make([][]string, 0) 8204 } else { 8205 sv = *v 8206 } 8207 8208 switch { 8209 default: 8210 var mv []string 8211 t := decoder.StartEl 8212 _ = t 8213 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8214 if err := awsRestxml_deserializeDocumentStringList(&mv, nodeDecoder); err != nil { 8215 return err 8216 } 8217 sv = append(sv, mv) 8218 } 8219 *v = sv 8220 return nil 8221} 8222func awsRestxml_deserializeDocumentStringList(v *[]string, decoder smithyxml.NodeDecoder) error { 8223 if v == nil { 8224 return fmt.Errorf("unexpected nil of type %T", v) 8225 } 8226 var sv []string 8227 if *v == nil { 8228 sv = make([]string, 0) 8229 } else { 8230 sv = *v 8231 } 8232 8233 originalDecoder := decoder 8234 for { 8235 t, done, err := decoder.Token() 8236 if err != nil { 8237 return err 8238 } 8239 if done { 8240 break 8241 } 8242 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8243 decoder = memberDecoder 8244 switch { 8245 case strings.EqualFold("member", t.Name.Local): 8246 var col string 8247 val, err := decoder.Value() 8248 if err != nil { 8249 return err 8250 } 8251 if val == nil { 8252 break 8253 } 8254 { 8255 xtv := string(val) 8256 col = xtv 8257 } 8258 sv = append(sv, col) 8259 8260 default: 8261 err = decoder.Decoder.Skip() 8262 if err != nil { 8263 return err 8264 } 8265 8266 } 8267 decoder = originalDecoder 8268 } 8269 *v = sv 8270 return nil 8271} 8272 8273func awsRestxml_deserializeDocumentStringListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 8274 var sv []string 8275 if *v == nil { 8276 sv = make([]string, 0) 8277 } else { 8278 sv = *v 8279 } 8280 8281 switch { 8282 default: 8283 var mv string 8284 t := decoder.StartEl 8285 _ = t 8286 val, err := decoder.Value() 8287 if err != nil { 8288 return err 8289 } 8290 if val == nil { 8291 break 8292 } 8293 { 8294 xtv := string(val) 8295 mv = xtv 8296 } 8297 sv = append(sv, mv) 8298 } 8299 *v = sv 8300 return nil 8301} 8302func awsRestxml_deserializeDocumentStringSet(v *[]string, decoder smithyxml.NodeDecoder) error { 8303 if v == nil { 8304 return fmt.Errorf("unexpected nil of type %T", v) 8305 } 8306 var sv []string 8307 if *v == nil { 8308 sv = make([]string, 0) 8309 } else { 8310 sv = *v 8311 } 8312 8313 originalDecoder := decoder 8314 for { 8315 t, done, err := decoder.Token() 8316 if err != nil { 8317 return err 8318 } 8319 if done { 8320 break 8321 } 8322 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8323 decoder = memberDecoder 8324 switch { 8325 case strings.EqualFold("member", t.Name.Local): 8326 var col string 8327 val, err := decoder.Value() 8328 if err != nil { 8329 return err 8330 } 8331 if val == nil { 8332 break 8333 } 8334 { 8335 xtv := string(val) 8336 col = xtv 8337 } 8338 sv = append(sv, col) 8339 8340 default: 8341 err = decoder.Decoder.Skip() 8342 if err != nil { 8343 return err 8344 } 8345 8346 } 8347 decoder = originalDecoder 8348 } 8349 *v = sv 8350 return nil 8351} 8352 8353func awsRestxml_deserializeDocumentStringSetUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 8354 var sv []string 8355 if *v == nil { 8356 sv = make([]string, 0) 8357 } else { 8358 sv = *v 8359 } 8360 8361 switch { 8362 default: 8363 var mv string 8364 t := decoder.StartEl 8365 _ = t 8366 val, err := decoder.Value() 8367 if err != nil { 8368 return err 8369 } 8370 if val == nil { 8371 break 8372 } 8373 { 8374 xtv := string(val) 8375 mv = xtv 8376 } 8377 sv = append(sv, mv) 8378 } 8379 *v = sv 8380 return nil 8381} 8382func awsRestxml_deserializeDocumentTimestampList(v *[]time.Time, decoder smithyxml.NodeDecoder) error { 8383 if v == nil { 8384 return fmt.Errorf("unexpected nil of type %T", v) 8385 } 8386 var sv []time.Time 8387 if *v == nil { 8388 sv = make([]time.Time, 0) 8389 } else { 8390 sv = *v 8391 } 8392 8393 originalDecoder := decoder 8394 for { 8395 t, done, err := decoder.Token() 8396 if err != nil { 8397 return err 8398 } 8399 if done { 8400 break 8401 } 8402 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8403 decoder = memberDecoder 8404 switch { 8405 case strings.EqualFold("member", t.Name.Local): 8406 var col time.Time 8407 val, err := decoder.Value() 8408 if err != nil { 8409 return err 8410 } 8411 if val == nil { 8412 break 8413 } 8414 { 8415 xtv := string(val) 8416 t, err := smithytime.ParseDateTime(xtv) 8417 if err != nil { 8418 return err 8419 } 8420 col = t 8421 } 8422 sv = append(sv, col) 8423 8424 default: 8425 err = decoder.Decoder.Skip() 8426 if err != nil { 8427 return err 8428 } 8429 8430 } 8431 decoder = originalDecoder 8432 } 8433 *v = sv 8434 return nil 8435} 8436 8437func awsRestxml_deserializeDocumentTimestampListUnwrapped(v *[]time.Time, decoder smithyxml.NodeDecoder) error { 8438 var sv []time.Time 8439 if *v == nil { 8440 sv = make([]time.Time, 0) 8441 } else { 8442 sv = *v 8443 } 8444 8445 switch { 8446 default: 8447 var mv time.Time 8448 t := decoder.StartEl 8449 _ = t 8450 val, err := decoder.Value() 8451 if err != nil { 8452 return err 8453 } 8454 if val == nil { 8455 break 8456 } 8457 { 8458 xtv := string(val) 8459 t, err := smithytime.ParseDateTime(xtv) 8460 if err != nil { 8461 return err 8462 } 8463 mv = t 8464 } 8465 sv = append(sv, mv) 8466 } 8467 *v = sv 8468 return nil 8469} 8470