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