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