1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package s3 4 5import ( 6 "bytes" 7 "context" 8 "encoding/xml" 9 "fmt" 10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 11 "github.com/aws/aws-sdk-go-v2/service/internal/s3shared" 12 "github.com/aws/aws-sdk-go-v2/service/s3/types" 13 smithy "github.com/aws/smithy-go" 14 smithyxml "github.com/aws/smithy-go/encoding/xml" 15 smithyio "github.com/aws/smithy-go/io" 16 "github.com/aws/smithy-go/middleware" 17 "github.com/aws/smithy-go/ptr" 18 smithytime "github.com/aws/smithy-go/time" 19 smithyhttp "github.com/aws/smithy-go/transport/http" 20 "io" 21 "io/ioutil" 22 "strconv" 23 "strings" 24) 25 26type awsRestxml_deserializeOpAbortMultipartUpload struct { 27} 28 29func (*awsRestxml_deserializeOpAbortMultipartUpload) ID() string { 30 return "OperationDeserializer" 31} 32 33func (m *awsRestxml_deserializeOpAbortMultipartUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 34 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 35) { 36 out, metadata, err = next.HandleDeserialize(ctx, in) 37 if err != nil { 38 return out, metadata, err 39 } 40 41 response, ok := out.RawResponse.(*smithyhttp.Response) 42 if !ok { 43 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 44 } 45 46 if response.StatusCode < 200 || response.StatusCode >= 300 { 47 return out, metadata, awsRestxml_deserializeOpErrorAbortMultipartUpload(response, &metadata) 48 } 49 output := &AbortMultipartUploadOutput{} 50 out.Result = output 51 52 err = awsRestxml_deserializeOpHttpBindingsAbortMultipartUploadOutput(output, response) 53 if err != nil { 54 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 55 } 56 57 return out, metadata, err 58} 59 60func awsRestxml_deserializeOpErrorAbortMultipartUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error { 61 var errorBuffer bytes.Buffer 62 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 63 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 64 } 65 errorBody := bytes.NewReader(errorBuffer.Bytes()) 66 67 errorCode := "UnknownError" 68 errorMessage := errorCode 69 70 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 71 UseStatusCode: true, StatusCode: response.StatusCode, 72 }) 73 if err != nil { 74 return err 75 } 76 if hostID := errorComponents.HostID; len(hostID) != 0 { 77 s3shared.SetHostIDMetadata(metadata, hostID) 78 } 79 if reqID := errorComponents.RequestID; len(reqID) != 0 { 80 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 81 } 82 if len(errorComponents.Code) != 0 { 83 errorCode = errorComponents.Code 84 } 85 if len(errorComponents.Message) != 0 { 86 errorMessage = errorComponents.Message 87 } 88 errorBody.Seek(0, io.SeekStart) 89 switch { 90 case strings.EqualFold("NoSuchUpload", errorCode): 91 return awsRestxml_deserializeErrorNoSuchUpload(response, errorBody) 92 93 default: 94 genericError := &smithy.GenericAPIError{ 95 Code: errorCode, 96 Message: errorMessage, 97 } 98 return genericError 99 100 } 101} 102 103func awsRestxml_deserializeOpHttpBindingsAbortMultipartUploadOutput(v *AbortMultipartUploadOutput, response *smithyhttp.Response) error { 104 if v == nil { 105 return fmt.Errorf("unsupported deserialization for nil %T", v) 106 } 107 108 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 109 headerValues[0] = strings.TrimSpace(headerValues[0]) 110 v.RequestCharged = types.RequestCharged(headerValues[0]) 111 } 112 113 return nil 114} 115 116type awsRestxml_deserializeOpCompleteMultipartUpload struct { 117} 118 119func (*awsRestxml_deserializeOpCompleteMultipartUpload) ID() string { 120 return "OperationDeserializer" 121} 122 123func (m *awsRestxml_deserializeOpCompleteMultipartUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 124 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 125) { 126 out, metadata, err = next.HandleDeserialize(ctx, in) 127 if err != nil { 128 return out, metadata, err 129 } 130 131 response, ok := out.RawResponse.(*smithyhttp.Response) 132 if !ok { 133 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 134 } 135 136 if response.StatusCode < 200 || response.StatusCode >= 300 { 137 return out, metadata, awsRestxml_deserializeOpErrorCompleteMultipartUpload(response, &metadata) 138 } 139 output := &CompleteMultipartUploadOutput{} 140 out.Result = output 141 142 err = awsRestxml_deserializeOpHttpBindingsCompleteMultipartUploadOutput(output, response) 143 if err != nil { 144 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 145 } 146 147 var buff [1024]byte 148 ringBuffer := smithyio.NewRingBuffer(buff[:]) 149 body := io.TeeReader(response.Body, ringBuffer) 150 rootDecoder := xml.NewDecoder(body) 151 t, err := smithyxml.FetchRootElement(rootDecoder) 152 if err == io.EOF { 153 return out, metadata, nil 154 } 155 if err != nil { 156 var snapshot bytes.Buffer 157 io.Copy(&snapshot, ringBuffer) 158 return out, metadata, &smithy.DeserializationError{ 159 Err: fmt.Errorf("failed to decode response body, %w", err), 160 Snapshot: snapshot.Bytes(), 161 } 162 } 163 164 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 165 err = awsRestxml_deserializeOpDocumentCompleteMultipartUploadOutput(&output, decoder) 166 if err != nil { 167 var snapshot bytes.Buffer 168 io.Copy(&snapshot, ringBuffer) 169 return out, metadata, &smithy.DeserializationError{ 170 Err: fmt.Errorf("failed to decode response body, %w", err), 171 Snapshot: snapshot.Bytes(), 172 } 173 } 174 175 return out, metadata, err 176} 177 178func awsRestxml_deserializeOpErrorCompleteMultipartUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error { 179 var errorBuffer bytes.Buffer 180 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 181 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 182 } 183 errorBody := bytes.NewReader(errorBuffer.Bytes()) 184 185 errorCode := "UnknownError" 186 errorMessage := errorCode 187 188 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 189 UseStatusCode: true, StatusCode: response.StatusCode, 190 }) 191 if err != nil { 192 return err 193 } 194 if hostID := errorComponents.HostID; len(hostID) != 0 { 195 s3shared.SetHostIDMetadata(metadata, hostID) 196 } 197 if reqID := errorComponents.RequestID; len(reqID) != 0 { 198 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 199 } 200 if len(errorComponents.Code) != 0 { 201 errorCode = errorComponents.Code 202 } 203 if len(errorComponents.Message) != 0 { 204 errorMessage = errorComponents.Message 205 } 206 errorBody.Seek(0, io.SeekStart) 207 switch { 208 default: 209 genericError := &smithy.GenericAPIError{ 210 Code: errorCode, 211 Message: errorMessage, 212 } 213 return genericError 214 215 } 216} 217 218func awsRestxml_deserializeOpHttpBindingsCompleteMultipartUploadOutput(v *CompleteMultipartUploadOutput, response *smithyhttp.Response) error { 219 if v == nil { 220 return fmt.Errorf("unsupported deserialization for nil %T", v) 221 } 222 223 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 224 headerValues[0] = strings.TrimSpace(headerValues[0]) 225 vv, err := strconv.ParseBool(headerValues[0]) 226 if err != nil { 227 return err 228 } 229 v.BucketKeyEnabled = vv 230 } 231 232 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 233 headerValues[0] = strings.TrimSpace(headerValues[0]) 234 v.Expiration = ptr.String(headerValues[0]) 235 } 236 237 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 238 headerValues[0] = strings.TrimSpace(headerValues[0]) 239 v.RequestCharged = types.RequestCharged(headerValues[0]) 240 } 241 242 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 243 headerValues[0] = strings.TrimSpace(headerValues[0]) 244 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 245 } 246 247 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 248 headerValues[0] = strings.TrimSpace(headerValues[0]) 249 v.SSEKMSKeyId = ptr.String(headerValues[0]) 250 } 251 252 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 253 headerValues[0] = strings.TrimSpace(headerValues[0]) 254 v.VersionId = ptr.String(headerValues[0]) 255 } 256 257 return nil 258} 259func awsRestxml_deserializeOpDocumentCompleteMultipartUploadOutput(v **CompleteMultipartUploadOutput, decoder smithyxml.NodeDecoder) error { 260 if v == nil { 261 return fmt.Errorf("unexpected nil of type %T", v) 262 } 263 var sv *CompleteMultipartUploadOutput 264 if *v == nil { 265 sv = &CompleteMultipartUploadOutput{} 266 } else { 267 sv = *v 268 } 269 270 for { 271 t, done, err := decoder.Token() 272 if err != nil { 273 return err 274 } 275 if done { 276 break 277 } 278 originalDecoder := decoder 279 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 280 switch { 281 case strings.EqualFold("Bucket", t.Name.Local): 282 val, err := decoder.Value() 283 if err != nil { 284 return err 285 } 286 if val == nil { 287 break 288 } 289 { 290 xtv := string(val) 291 sv.Bucket = ptr.String(xtv) 292 } 293 294 case strings.EqualFold("ETag", t.Name.Local): 295 val, err := decoder.Value() 296 if err != nil { 297 return err 298 } 299 if val == nil { 300 break 301 } 302 { 303 xtv := string(val) 304 sv.ETag = ptr.String(xtv) 305 } 306 307 case strings.EqualFold("Key", t.Name.Local): 308 val, err := decoder.Value() 309 if err != nil { 310 return err 311 } 312 if val == nil { 313 break 314 } 315 { 316 xtv := string(val) 317 sv.Key = ptr.String(xtv) 318 } 319 320 case strings.EqualFold("Location", t.Name.Local): 321 val, err := decoder.Value() 322 if err != nil { 323 return err 324 } 325 if val == nil { 326 break 327 } 328 { 329 xtv := string(val) 330 sv.Location = ptr.String(xtv) 331 } 332 333 default: 334 // Do nothing and ignore the unexpected tag element 335 err = decoder.Decoder.Skip() 336 if err != nil { 337 return err 338 } 339 340 } 341 decoder = originalDecoder 342 } 343 *v = sv 344 return nil 345} 346 347type awsRestxml_deserializeOpCopyObject struct { 348} 349 350func (*awsRestxml_deserializeOpCopyObject) ID() string { 351 return "OperationDeserializer" 352} 353 354func (m *awsRestxml_deserializeOpCopyObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 355 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 356) { 357 out, metadata, err = next.HandleDeserialize(ctx, in) 358 if err != nil { 359 return out, metadata, err 360 } 361 362 response, ok := out.RawResponse.(*smithyhttp.Response) 363 if !ok { 364 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 365 } 366 367 if response.StatusCode < 200 || response.StatusCode >= 300 { 368 return out, metadata, awsRestxml_deserializeOpErrorCopyObject(response, &metadata) 369 } 370 output := &CopyObjectOutput{} 371 out.Result = output 372 373 err = awsRestxml_deserializeOpHttpBindingsCopyObjectOutput(output, response) 374 if err != nil { 375 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 376 } 377 378 var buff [1024]byte 379 ringBuffer := smithyio.NewRingBuffer(buff[:]) 380 body := io.TeeReader(response.Body, ringBuffer) 381 rootDecoder := xml.NewDecoder(body) 382 t, err := smithyxml.FetchRootElement(rootDecoder) 383 if err == io.EOF { 384 return out, metadata, nil 385 } 386 if err != nil { 387 var snapshot bytes.Buffer 388 io.Copy(&snapshot, ringBuffer) 389 return out, metadata, &smithy.DeserializationError{ 390 Err: fmt.Errorf("failed to decode response body, %w", err), 391 Snapshot: snapshot.Bytes(), 392 } 393 } 394 395 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 396 err = awsRestxml_deserializeDocumentCopyObjectResult(&output.CopyObjectResult, decoder) 397 if err != nil { 398 var snapshot bytes.Buffer 399 io.Copy(&snapshot, ringBuffer) 400 return out, metadata, &smithy.DeserializationError{ 401 Err: fmt.Errorf("failed to decode response body, %w", err), 402 Snapshot: snapshot.Bytes(), 403 } 404 } 405 406 return out, metadata, err 407} 408 409func awsRestxml_deserializeOpErrorCopyObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 410 var errorBuffer bytes.Buffer 411 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 412 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 413 } 414 errorBody := bytes.NewReader(errorBuffer.Bytes()) 415 416 errorCode := "UnknownError" 417 errorMessage := errorCode 418 419 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 420 UseStatusCode: true, StatusCode: response.StatusCode, 421 }) 422 if err != nil { 423 return err 424 } 425 if hostID := errorComponents.HostID; len(hostID) != 0 { 426 s3shared.SetHostIDMetadata(metadata, hostID) 427 } 428 if reqID := errorComponents.RequestID; len(reqID) != 0 { 429 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 430 } 431 if len(errorComponents.Code) != 0 { 432 errorCode = errorComponents.Code 433 } 434 if len(errorComponents.Message) != 0 { 435 errorMessage = errorComponents.Message 436 } 437 errorBody.Seek(0, io.SeekStart) 438 switch { 439 case strings.EqualFold("ObjectNotInActiveTierError", errorCode): 440 return awsRestxml_deserializeErrorObjectNotInActiveTierError(response, errorBody) 441 442 default: 443 genericError := &smithy.GenericAPIError{ 444 Code: errorCode, 445 Message: errorMessage, 446 } 447 return genericError 448 449 } 450} 451 452func awsRestxml_deserializeOpHttpBindingsCopyObjectOutput(v *CopyObjectOutput, response *smithyhttp.Response) error { 453 if v == nil { 454 return fmt.Errorf("unsupported deserialization for nil %T", v) 455 } 456 457 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 458 headerValues[0] = strings.TrimSpace(headerValues[0]) 459 vv, err := strconv.ParseBool(headerValues[0]) 460 if err != nil { 461 return err 462 } 463 v.BucketKeyEnabled = vv 464 } 465 466 if headerValues := response.Header.Values("x-amz-copy-source-version-id"); len(headerValues) != 0 { 467 headerValues[0] = strings.TrimSpace(headerValues[0]) 468 v.CopySourceVersionId = ptr.String(headerValues[0]) 469 } 470 471 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 472 headerValues[0] = strings.TrimSpace(headerValues[0]) 473 v.Expiration = ptr.String(headerValues[0]) 474 } 475 476 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 477 headerValues[0] = strings.TrimSpace(headerValues[0]) 478 v.RequestCharged = types.RequestCharged(headerValues[0]) 479 } 480 481 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 482 headerValues[0] = strings.TrimSpace(headerValues[0]) 483 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 484 } 485 486 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 487 headerValues[0] = strings.TrimSpace(headerValues[0]) 488 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 489 } 490 491 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 492 headerValues[0] = strings.TrimSpace(headerValues[0]) 493 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 494 } 495 496 if headerValues := response.Header.Values("x-amz-server-side-encryption-context"); len(headerValues) != 0 { 497 headerValues[0] = strings.TrimSpace(headerValues[0]) 498 v.SSEKMSEncryptionContext = ptr.String(headerValues[0]) 499 } 500 501 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 502 headerValues[0] = strings.TrimSpace(headerValues[0]) 503 v.SSEKMSKeyId = ptr.String(headerValues[0]) 504 } 505 506 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 507 headerValues[0] = strings.TrimSpace(headerValues[0]) 508 v.VersionId = ptr.String(headerValues[0]) 509 } 510 511 return nil 512} 513func awsRestxml_deserializeOpDocumentCopyObjectOutput(v **CopyObjectOutput, decoder smithyxml.NodeDecoder) error { 514 if v == nil { 515 return fmt.Errorf("unexpected nil of type %T", v) 516 } 517 var sv *CopyObjectOutput 518 if *v == nil { 519 sv = &CopyObjectOutput{} 520 } else { 521 sv = *v 522 } 523 524 for { 525 t, done, err := decoder.Token() 526 if err != nil { 527 return err 528 } 529 if done { 530 break 531 } 532 originalDecoder := decoder 533 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 534 switch { 535 case strings.EqualFold("CopyObjectResult", t.Name.Local): 536 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 537 if err := awsRestxml_deserializeDocumentCopyObjectResult(&sv.CopyObjectResult, nodeDecoder); err != nil { 538 return err 539 } 540 541 default: 542 // Do nothing and ignore the unexpected tag element 543 err = decoder.Decoder.Skip() 544 if err != nil { 545 return err 546 } 547 548 } 549 decoder = originalDecoder 550 } 551 *v = sv 552 return nil 553} 554 555type awsRestxml_deserializeOpCreateBucket struct { 556} 557 558func (*awsRestxml_deserializeOpCreateBucket) ID() string { 559 return "OperationDeserializer" 560} 561 562func (m *awsRestxml_deserializeOpCreateBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 563 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 564) { 565 out, metadata, err = next.HandleDeserialize(ctx, in) 566 if err != nil { 567 return out, metadata, err 568 } 569 570 response, ok := out.RawResponse.(*smithyhttp.Response) 571 if !ok { 572 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 573 } 574 575 if response.StatusCode < 200 || response.StatusCode >= 300 { 576 return out, metadata, awsRestxml_deserializeOpErrorCreateBucket(response, &metadata) 577 } 578 output := &CreateBucketOutput{} 579 out.Result = output 580 581 err = awsRestxml_deserializeOpHttpBindingsCreateBucketOutput(output, response) 582 if err != nil { 583 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 584 } 585 586 return out, metadata, err 587} 588 589func awsRestxml_deserializeOpErrorCreateBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 590 var errorBuffer bytes.Buffer 591 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 592 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 593 } 594 errorBody := bytes.NewReader(errorBuffer.Bytes()) 595 596 errorCode := "UnknownError" 597 errorMessage := errorCode 598 599 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 600 UseStatusCode: true, StatusCode: response.StatusCode, 601 }) 602 if err != nil { 603 return err 604 } 605 if hostID := errorComponents.HostID; len(hostID) != 0 { 606 s3shared.SetHostIDMetadata(metadata, hostID) 607 } 608 if reqID := errorComponents.RequestID; len(reqID) != 0 { 609 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 610 } 611 if len(errorComponents.Code) != 0 { 612 errorCode = errorComponents.Code 613 } 614 if len(errorComponents.Message) != 0 { 615 errorMessage = errorComponents.Message 616 } 617 errorBody.Seek(0, io.SeekStart) 618 switch { 619 case strings.EqualFold("BucketAlreadyExists", errorCode): 620 return awsRestxml_deserializeErrorBucketAlreadyExists(response, errorBody) 621 622 case strings.EqualFold("BucketAlreadyOwnedByYou", errorCode): 623 return awsRestxml_deserializeErrorBucketAlreadyOwnedByYou(response, errorBody) 624 625 default: 626 genericError := &smithy.GenericAPIError{ 627 Code: errorCode, 628 Message: errorMessage, 629 } 630 return genericError 631 632 } 633} 634 635func awsRestxml_deserializeOpHttpBindingsCreateBucketOutput(v *CreateBucketOutput, response *smithyhttp.Response) error { 636 if v == nil { 637 return fmt.Errorf("unsupported deserialization for nil %T", v) 638 } 639 640 if headerValues := response.Header.Values("Location"); len(headerValues) != 0 { 641 headerValues[0] = strings.TrimSpace(headerValues[0]) 642 v.Location = ptr.String(headerValues[0]) 643 } 644 645 return nil 646} 647 648type awsRestxml_deserializeOpCreateMultipartUpload struct { 649} 650 651func (*awsRestxml_deserializeOpCreateMultipartUpload) ID() string { 652 return "OperationDeserializer" 653} 654 655func (m *awsRestxml_deserializeOpCreateMultipartUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 656 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 657) { 658 out, metadata, err = next.HandleDeserialize(ctx, in) 659 if err != nil { 660 return out, metadata, err 661 } 662 663 response, ok := out.RawResponse.(*smithyhttp.Response) 664 if !ok { 665 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 666 } 667 668 if response.StatusCode < 200 || response.StatusCode >= 300 { 669 return out, metadata, awsRestxml_deserializeOpErrorCreateMultipartUpload(response, &metadata) 670 } 671 output := &CreateMultipartUploadOutput{} 672 out.Result = output 673 674 err = awsRestxml_deserializeOpHttpBindingsCreateMultipartUploadOutput(output, response) 675 if err != nil { 676 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 677 } 678 679 var buff [1024]byte 680 ringBuffer := smithyio.NewRingBuffer(buff[:]) 681 body := io.TeeReader(response.Body, ringBuffer) 682 rootDecoder := xml.NewDecoder(body) 683 t, err := smithyxml.FetchRootElement(rootDecoder) 684 if err == io.EOF { 685 return out, metadata, nil 686 } 687 if err != nil { 688 var snapshot bytes.Buffer 689 io.Copy(&snapshot, ringBuffer) 690 return out, metadata, &smithy.DeserializationError{ 691 Err: fmt.Errorf("failed to decode response body, %w", err), 692 Snapshot: snapshot.Bytes(), 693 } 694 } 695 696 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 697 err = awsRestxml_deserializeOpDocumentCreateMultipartUploadOutput(&output, decoder) 698 if err != nil { 699 var snapshot bytes.Buffer 700 io.Copy(&snapshot, ringBuffer) 701 return out, metadata, &smithy.DeserializationError{ 702 Err: fmt.Errorf("failed to decode response body, %w", err), 703 Snapshot: snapshot.Bytes(), 704 } 705 } 706 707 return out, metadata, err 708} 709 710func awsRestxml_deserializeOpErrorCreateMultipartUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error { 711 var errorBuffer bytes.Buffer 712 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 713 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 714 } 715 errorBody := bytes.NewReader(errorBuffer.Bytes()) 716 717 errorCode := "UnknownError" 718 errorMessage := errorCode 719 720 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 721 UseStatusCode: true, StatusCode: response.StatusCode, 722 }) 723 if err != nil { 724 return err 725 } 726 if hostID := errorComponents.HostID; len(hostID) != 0 { 727 s3shared.SetHostIDMetadata(metadata, hostID) 728 } 729 if reqID := errorComponents.RequestID; len(reqID) != 0 { 730 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 731 } 732 if len(errorComponents.Code) != 0 { 733 errorCode = errorComponents.Code 734 } 735 if len(errorComponents.Message) != 0 { 736 errorMessage = errorComponents.Message 737 } 738 errorBody.Seek(0, io.SeekStart) 739 switch { 740 default: 741 genericError := &smithy.GenericAPIError{ 742 Code: errorCode, 743 Message: errorMessage, 744 } 745 return genericError 746 747 } 748} 749 750func awsRestxml_deserializeOpHttpBindingsCreateMultipartUploadOutput(v *CreateMultipartUploadOutput, response *smithyhttp.Response) error { 751 if v == nil { 752 return fmt.Errorf("unsupported deserialization for nil %T", v) 753 } 754 755 if headerValues := response.Header.Values("x-amz-abort-date"); len(headerValues) != 0 { 756 headerValues[0] = strings.TrimSpace(headerValues[0]) 757 t, err := smithytime.ParseHTTPDate(headerValues[0]) 758 if err != nil { 759 return err 760 } 761 v.AbortDate = ptr.Time(t) 762 } 763 764 if headerValues := response.Header.Values("x-amz-abort-rule-id"); len(headerValues) != 0 { 765 headerValues[0] = strings.TrimSpace(headerValues[0]) 766 v.AbortRuleId = ptr.String(headerValues[0]) 767 } 768 769 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 770 headerValues[0] = strings.TrimSpace(headerValues[0]) 771 vv, err := strconv.ParseBool(headerValues[0]) 772 if err != nil { 773 return err 774 } 775 v.BucketKeyEnabled = vv 776 } 777 778 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 779 headerValues[0] = strings.TrimSpace(headerValues[0]) 780 v.RequestCharged = types.RequestCharged(headerValues[0]) 781 } 782 783 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 784 headerValues[0] = strings.TrimSpace(headerValues[0]) 785 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 786 } 787 788 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 789 headerValues[0] = strings.TrimSpace(headerValues[0]) 790 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 791 } 792 793 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 794 headerValues[0] = strings.TrimSpace(headerValues[0]) 795 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 796 } 797 798 if headerValues := response.Header.Values("x-amz-server-side-encryption-context"); len(headerValues) != 0 { 799 headerValues[0] = strings.TrimSpace(headerValues[0]) 800 v.SSEKMSEncryptionContext = ptr.String(headerValues[0]) 801 } 802 803 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 804 headerValues[0] = strings.TrimSpace(headerValues[0]) 805 v.SSEKMSKeyId = ptr.String(headerValues[0]) 806 } 807 808 return nil 809} 810func awsRestxml_deserializeOpDocumentCreateMultipartUploadOutput(v **CreateMultipartUploadOutput, decoder smithyxml.NodeDecoder) error { 811 if v == nil { 812 return fmt.Errorf("unexpected nil of type %T", v) 813 } 814 var sv *CreateMultipartUploadOutput 815 if *v == nil { 816 sv = &CreateMultipartUploadOutput{} 817 } else { 818 sv = *v 819 } 820 821 for { 822 t, done, err := decoder.Token() 823 if err != nil { 824 return err 825 } 826 if done { 827 break 828 } 829 originalDecoder := decoder 830 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 831 switch { 832 case strings.EqualFold("Bucket", t.Name.Local): 833 val, err := decoder.Value() 834 if err != nil { 835 return err 836 } 837 if val == nil { 838 break 839 } 840 { 841 xtv := string(val) 842 sv.Bucket = ptr.String(xtv) 843 } 844 845 case strings.EqualFold("Key", t.Name.Local): 846 val, err := decoder.Value() 847 if err != nil { 848 return err 849 } 850 if val == nil { 851 break 852 } 853 { 854 xtv := string(val) 855 sv.Key = ptr.String(xtv) 856 } 857 858 case strings.EqualFold("UploadId", t.Name.Local): 859 val, err := decoder.Value() 860 if err != nil { 861 return err 862 } 863 if val == nil { 864 break 865 } 866 { 867 xtv := string(val) 868 sv.UploadId = ptr.String(xtv) 869 } 870 871 default: 872 // Do nothing and ignore the unexpected tag element 873 err = decoder.Decoder.Skip() 874 if err != nil { 875 return err 876 } 877 878 } 879 decoder = originalDecoder 880 } 881 *v = sv 882 return nil 883} 884 885type awsRestxml_deserializeOpDeleteBucket struct { 886} 887 888func (*awsRestxml_deserializeOpDeleteBucket) ID() string { 889 return "OperationDeserializer" 890} 891 892func (m *awsRestxml_deserializeOpDeleteBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 893 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 894) { 895 out, metadata, err = next.HandleDeserialize(ctx, in) 896 if err != nil { 897 return out, metadata, err 898 } 899 900 response, ok := out.RawResponse.(*smithyhttp.Response) 901 if !ok { 902 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 903 } 904 905 if response.StatusCode < 200 || response.StatusCode >= 300 { 906 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucket(response, &metadata) 907 } 908 output := &DeleteBucketOutput{} 909 out.Result = output 910 911 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 912 return out, metadata, &smithy.DeserializationError{ 913 Err: fmt.Errorf("failed to discard response body, %w", err), 914 } 915 } 916 917 return out, metadata, err 918} 919 920func awsRestxml_deserializeOpErrorDeleteBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 921 var errorBuffer bytes.Buffer 922 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 923 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 924 } 925 errorBody := bytes.NewReader(errorBuffer.Bytes()) 926 927 errorCode := "UnknownError" 928 errorMessage := errorCode 929 930 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 931 UseStatusCode: true, StatusCode: response.StatusCode, 932 }) 933 if err != nil { 934 return err 935 } 936 if hostID := errorComponents.HostID; len(hostID) != 0 { 937 s3shared.SetHostIDMetadata(metadata, hostID) 938 } 939 if reqID := errorComponents.RequestID; len(reqID) != 0 { 940 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 941 } 942 if len(errorComponents.Code) != 0 { 943 errorCode = errorComponents.Code 944 } 945 if len(errorComponents.Message) != 0 { 946 errorMessage = errorComponents.Message 947 } 948 errorBody.Seek(0, io.SeekStart) 949 switch { 950 default: 951 genericError := &smithy.GenericAPIError{ 952 Code: errorCode, 953 Message: errorMessage, 954 } 955 return genericError 956 957 } 958} 959 960type awsRestxml_deserializeOpDeleteBucketAnalyticsConfiguration struct { 961} 962 963func (*awsRestxml_deserializeOpDeleteBucketAnalyticsConfiguration) ID() string { 964 return "OperationDeserializer" 965} 966 967func (m *awsRestxml_deserializeOpDeleteBucketAnalyticsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 968 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 969) { 970 out, metadata, err = next.HandleDeserialize(ctx, in) 971 if err != nil { 972 return out, metadata, err 973 } 974 975 response, ok := out.RawResponse.(*smithyhttp.Response) 976 if !ok { 977 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 978 } 979 980 if response.StatusCode < 200 || response.StatusCode >= 300 { 981 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketAnalyticsConfiguration(response, &metadata) 982 } 983 output := &DeleteBucketAnalyticsConfigurationOutput{} 984 out.Result = output 985 986 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 987 return out, metadata, &smithy.DeserializationError{ 988 Err: fmt.Errorf("failed to discard response body, %w", err), 989 } 990 } 991 992 return out, metadata, err 993} 994 995func awsRestxml_deserializeOpErrorDeleteBucketAnalyticsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 996 var errorBuffer bytes.Buffer 997 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 998 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 999 } 1000 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1001 1002 errorCode := "UnknownError" 1003 errorMessage := errorCode 1004 1005 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1006 UseStatusCode: true, StatusCode: response.StatusCode, 1007 }) 1008 if err != nil { 1009 return err 1010 } 1011 if hostID := errorComponents.HostID; len(hostID) != 0 { 1012 s3shared.SetHostIDMetadata(metadata, hostID) 1013 } 1014 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1015 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1016 } 1017 if len(errorComponents.Code) != 0 { 1018 errorCode = errorComponents.Code 1019 } 1020 if len(errorComponents.Message) != 0 { 1021 errorMessage = errorComponents.Message 1022 } 1023 errorBody.Seek(0, io.SeekStart) 1024 switch { 1025 default: 1026 genericError := &smithy.GenericAPIError{ 1027 Code: errorCode, 1028 Message: errorMessage, 1029 } 1030 return genericError 1031 1032 } 1033} 1034 1035type awsRestxml_deserializeOpDeleteBucketCors struct { 1036} 1037 1038func (*awsRestxml_deserializeOpDeleteBucketCors) ID() string { 1039 return "OperationDeserializer" 1040} 1041 1042func (m *awsRestxml_deserializeOpDeleteBucketCors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1043 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1044) { 1045 out, metadata, err = next.HandleDeserialize(ctx, in) 1046 if err != nil { 1047 return out, metadata, err 1048 } 1049 1050 response, ok := out.RawResponse.(*smithyhttp.Response) 1051 if !ok { 1052 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1053 } 1054 1055 if response.StatusCode < 200 || response.StatusCode >= 300 { 1056 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketCors(response, &metadata) 1057 } 1058 output := &DeleteBucketCorsOutput{} 1059 out.Result = output 1060 1061 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1062 return out, metadata, &smithy.DeserializationError{ 1063 Err: fmt.Errorf("failed to discard response body, %w", err), 1064 } 1065 } 1066 1067 return out, metadata, err 1068} 1069 1070func awsRestxml_deserializeOpErrorDeleteBucketCors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1071 var errorBuffer bytes.Buffer 1072 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1073 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1074 } 1075 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1076 1077 errorCode := "UnknownError" 1078 errorMessage := errorCode 1079 1080 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1081 UseStatusCode: true, StatusCode: response.StatusCode, 1082 }) 1083 if err != nil { 1084 return err 1085 } 1086 if hostID := errorComponents.HostID; len(hostID) != 0 { 1087 s3shared.SetHostIDMetadata(metadata, hostID) 1088 } 1089 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1090 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1091 } 1092 if len(errorComponents.Code) != 0 { 1093 errorCode = errorComponents.Code 1094 } 1095 if len(errorComponents.Message) != 0 { 1096 errorMessage = errorComponents.Message 1097 } 1098 errorBody.Seek(0, io.SeekStart) 1099 switch { 1100 default: 1101 genericError := &smithy.GenericAPIError{ 1102 Code: errorCode, 1103 Message: errorMessage, 1104 } 1105 return genericError 1106 1107 } 1108} 1109 1110type awsRestxml_deserializeOpDeleteBucketEncryption struct { 1111} 1112 1113func (*awsRestxml_deserializeOpDeleteBucketEncryption) ID() string { 1114 return "OperationDeserializer" 1115} 1116 1117func (m *awsRestxml_deserializeOpDeleteBucketEncryption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1118 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1119) { 1120 out, metadata, err = next.HandleDeserialize(ctx, in) 1121 if err != nil { 1122 return out, metadata, err 1123 } 1124 1125 response, ok := out.RawResponse.(*smithyhttp.Response) 1126 if !ok { 1127 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1128 } 1129 1130 if response.StatusCode < 200 || response.StatusCode >= 300 { 1131 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketEncryption(response, &metadata) 1132 } 1133 output := &DeleteBucketEncryptionOutput{} 1134 out.Result = output 1135 1136 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1137 return out, metadata, &smithy.DeserializationError{ 1138 Err: fmt.Errorf("failed to discard response body, %w", err), 1139 } 1140 } 1141 1142 return out, metadata, err 1143} 1144 1145func awsRestxml_deserializeOpErrorDeleteBucketEncryption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1146 var errorBuffer bytes.Buffer 1147 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1148 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1149 } 1150 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1151 1152 errorCode := "UnknownError" 1153 errorMessage := errorCode 1154 1155 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1156 UseStatusCode: true, StatusCode: response.StatusCode, 1157 }) 1158 if err != nil { 1159 return err 1160 } 1161 if hostID := errorComponents.HostID; len(hostID) != 0 { 1162 s3shared.SetHostIDMetadata(metadata, hostID) 1163 } 1164 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1165 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1166 } 1167 if len(errorComponents.Code) != 0 { 1168 errorCode = errorComponents.Code 1169 } 1170 if len(errorComponents.Message) != 0 { 1171 errorMessage = errorComponents.Message 1172 } 1173 errorBody.Seek(0, io.SeekStart) 1174 switch { 1175 default: 1176 genericError := &smithy.GenericAPIError{ 1177 Code: errorCode, 1178 Message: errorMessage, 1179 } 1180 return genericError 1181 1182 } 1183} 1184 1185type awsRestxml_deserializeOpDeleteBucketIntelligentTieringConfiguration struct { 1186} 1187 1188func (*awsRestxml_deserializeOpDeleteBucketIntelligentTieringConfiguration) ID() string { 1189 return "OperationDeserializer" 1190} 1191 1192func (m *awsRestxml_deserializeOpDeleteBucketIntelligentTieringConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1193 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1194) { 1195 out, metadata, err = next.HandleDeserialize(ctx, in) 1196 if err != nil { 1197 return out, metadata, err 1198 } 1199 1200 response, ok := out.RawResponse.(*smithyhttp.Response) 1201 if !ok { 1202 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1203 } 1204 1205 if response.StatusCode < 200 || response.StatusCode >= 300 { 1206 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketIntelligentTieringConfiguration(response, &metadata) 1207 } 1208 output := &DeleteBucketIntelligentTieringConfigurationOutput{} 1209 out.Result = output 1210 1211 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1212 return out, metadata, &smithy.DeserializationError{ 1213 Err: fmt.Errorf("failed to discard response body, %w", err), 1214 } 1215 } 1216 1217 return out, metadata, err 1218} 1219 1220func awsRestxml_deserializeOpErrorDeleteBucketIntelligentTieringConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1221 var errorBuffer bytes.Buffer 1222 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1223 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1224 } 1225 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1226 1227 errorCode := "UnknownError" 1228 errorMessage := errorCode 1229 1230 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1231 UseStatusCode: true, StatusCode: response.StatusCode, 1232 }) 1233 if err != nil { 1234 return err 1235 } 1236 if hostID := errorComponents.HostID; len(hostID) != 0 { 1237 s3shared.SetHostIDMetadata(metadata, hostID) 1238 } 1239 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1240 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1241 } 1242 if len(errorComponents.Code) != 0 { 1243 errorCode = errorComponents.Code 1244 } 1245 if len(errorComponents.Message) != 0 { 1246 errorMessage = errorComponents.Message 1247 } 1248 errorBody.Seek(0, io.SeekStart) 1249 switch { 1250 default: 1251 genericError := &smithy.GenericAPIError{ 1252 Code: errorCode, 1253 Message: errorMessage, 1254 } 1255 return genericError 1256 1257 } 1258} 1259 1260type awsRestxml_deserializeOpDeleteBucketInventoryConfiguration struct { 1261} 1262 1263func (*awsRestxml_deserializeOpDeleteBucketInventoryConfiguration) ID() string { 1264 return "OperationDeserializer" 1265} 1266 1267func (m *awsRestxml_deserializeOpDeleteBucketInventoryConfiguration) 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_deserializeOpErrorDeleteBucketInventoryConfiguration(response, &metadata) 1282 } 1283 output := &DeleteBucketInventoryConfigurationOutput{} 1284 out.Result = output 1285 1286 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1287 return out, metadata, &smithy.DeserializationError{ 1288 Err: fmt.Errorf("failed to discard response body, %w", err), 1289 } 1290 } 1291 1292 return out, metadata, err 1293} 1294 1295func awsRestxml_deserializeOpErrorDeleteBucketInventoryConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1296 var errorBuffer bytes.Buffer 1297 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1298 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1299 } 1300 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1301 1302 errorCode := "UnknownError" 1303 errorMessage := errorCode 1304 1305 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1306 UseStatusCode: true, StatusCode: response.StatusCode, 1307 }) 1308 if err != nil { 1309 return err 1310 } 1311 if hostID := errorComponents.HostID; len(hostID) != 0 { 1312 s3shared.SetHostIDMetadata(metadata, hostID) 1313 } 1314 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1315 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1316 } 1317 if len(errorComponents.Code) != 0 { 1318 errorCode = errorComponents.Code 1319 } 1320 if len(errorComponents.Message) != 0 { 1321 errorMessage = errorComponents.Message 1322 } 1323 errorBody.Seek(0, io.SeekStart) 1324 switch { 1325 default: 1326 genericError := &smithy.GenericAPIError{ 1327 Code: errorCode, 1328 Message: errorMessage, 1329 } 1330 return genericError 1331 1332 } 1333} 1334 1335type awsRestxml_deserializeOpDeleteBucketLifecycle struct { 1336} 1337 1338func (*awsRestxml_deserializeOpDeleteBucketLifecycle) ID() string { 1339 return "OperationDeserializer" 1340} 1341 1342func (m *awsRestxml_deserializeOpDeleteBucketLifecycle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1343 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1344) { 1345 out, metadata, err = next.HandleDeserialize(ctx, in) 1346 if err != nil { 1347 return out, metadata, err 1348 } 1349 1350 response, ok := out.RawResponse.(*smithyhttp.Response) 1351 if !ok { 1352 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1353 } 1354 1355 if response.StatusCode < 200 || response.StatusCode >= 300 { 1356 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketLifecycle(response, &metadata) 1357 } 1358 output := &DeleteBucketLifecycleOutput{} 1359 out.Result = output 1360 1361 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1362 return out, metadata, &smithy.DeserializationError{ 1363 Err: fmt.Errorf("failed to discard response body, %w", err), 1364 } 1365 } 1366 1367 return out, metadata, err 1368} 1369 1370func awsRestxml_deserializeOpErrorDeleteBucketLifecycle(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1371 var errorBuffer bytes.Buffer 1372 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1373 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1374 } 1375 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1376 1377 errorCode := "UnknownError" 1378 errorMessage := errorCode 1379 1380 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1381 UseStatusCode: true, StatusCode: response.StatusCode, 1382 }) 1383 if err != nil { 1384 return err 1385 } 1386 if hostID := errorComponents.HostID; len(hostID) != 0 { 1387 s3shared.SetHostIDMetadata(metadata, hostID) 1388 } 1389 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1390 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1391 } 1392 if len(errorComponents.Code) != 0 { 1393 errorCode = errorComponents.Code 1394 } 1395 if len(errorComponents.Message) != 0 { 1396 errorMessage = errorComponents.Message 1397 } 1398 errorBody.Seek(0, io.SeekStart) 1399 switch { 1400 default: 1401 genericError := &smithy.GenericAPIError{ 1402 Code: errorCode, 1403 Message: errorMessage, 1404 } 1405 return genericError 1406 1407 } 1408} 1409 1410type awsRestxml_deserializeOpDeleteBucketMetricsConfiguration struct { 1411} 1412 1413func (*awsRestxml_deserializeOpDeleteBucketMetricsConfiguration) ID() string { 1414 return "OperationDeserializer" 1415} 1416 1417func (m *awsRestxml_deserializeOpDeleteBucketMetricsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1418 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1419) { 1420 out, metadata, err = next.HandleDeserialize(ctx, in) 1421 if err != nil { 1422 return out, metadata, err 1423 } 1424 1425 response, ok := out.RawResponse.(*smithyhttp.Response) 1426 if !ok { 1427 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1428 } 1429 1430 if response.StatusCode < 200 || response.StatusCode >= 300 { 1431 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketMetricsConfiguration(response, &metadata) 1432 } 1433 output := &DeleteBucketMetricsConfigurationOutput{} 1434 out.Result = output 1435 1436 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1437 return out, metadata, &smithy.DeserializationError{ 1438 Err: fmt.Errorf("failed to discard response body, %w", err), 1439 } 1440 } 1441 1442 return out, metadata, err 1443} 1444 1445func awsRestxml_deserializeOpErrorDeleteBucketMetricsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1446 var errorBuffer bytes.Buffer 1447 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1448 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1449 } 1450 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1451 1452 errorCode := "UnknownError" 1453 errorMessage := errorCode 1454 1455 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1456 UseStatusCode: true, StatusCode: response.StatusCode, 1457 }) 1458 if err != nil { 1459 return err 1460 } 1461 if hostID := errorComponents.HostID; len(hostID) != 0 { 1462 s3shared.SetHostIDMetadata(metadata, hostID) 1463 } 1464 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1465 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1466 } 1467 if len(errorComponents.Code) != 0 { 1468 errorCode = errorComponents.Code 1469 } 1470 if len(errorComponents.Message) != 0 { 1471 errorMessage = errorComponents.Message 1472 } 1473 errorBody.Seek(0, io.SeekStart) 1474 switch { 1475 default: 1476 genericError := &smithy.GenericAPIError{ 1477 Code: errorCode, 1478 Message: errorMessage, 1479 } 1480 return genericError 1481 1482 } 1483} 1484 1485type awsRestxml_deserializeOpDeleteBucketOwnershipControls struct { 1486} 1487 1488func (*awsRestxml_deserializeOpDeleteBucketOwnershipControls) ID() string { 1489 return "OperationDeserializer" 1490} 1491 1492func (m *awsRestxml_deserializeOpDeleteBucketOwnershipControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1493 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1494) { 1495 out, metadata, err = next.HandleDeserialize(ctx, in) 1496 if err != nil { 1497 return out, metadata, err 1498 } 1499 1500 response, ok := out.RawResponse.(*smithyhttp.Response) 1501 if !ok { 1502 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1503 } 1504 1505 if response.StatusCode < 200 || response.StatusCode >= 300 { 1506 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketOwnershipControls(response, &metadata) 1507 } 1508 output := &DeleteBucketOwnershipControlsOutput{} 1509 out.Result = output 1510 1511 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1512 return out, metadata, &smithy.DeserializationError{ 1513 Err: fmt.Errorf("failed to discard response body, %w", err), 1514 } 1515 } 1516 1517 return out, metadata, err 1518} 1519 1520func awsRestxml_deserializeOpErrorDeleteBucketOwnershipControls(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1521 var errorBuffer bytes.Buffer 1522 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1523 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1524 } 1525 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1526 1527 errorCode := "UnknownError" 1528 errorMessage := errorCode 1529 1530 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1531 UseStatusCode: true, StatusCode: response.StatusCode, 1532 }) 1533 if err != nil { 1534 return err 1535 } 1536 if hostID := errorComponents.HostID; len(hostID) != 0 { 1537 s3shared.SetHostIDMetadata(metadata, hostID) 1538 } 1539 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1540 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1541 } 1542 if len(errorComponents.Code) != 0 { 1543 errorCode = errorComponents.Code 1544 } 1545 if len(errorComponents.Message) != 0 { 1546 errorMessage = errorComponents.Message 1547 } 1548 errorBody.Seek(0, io.SeekStart) 1549 switch { 1550 default: 1551 genericError := &smithy.GenericAPIError{ 1552 Code: errorCode, 1553 Message: errorMessage, 1554 } 1555 return genericError 1556 1557 } 1558} 1559 1560type awsRestxml_deserializeOpDeleteBucketPolicy struct { 1561} 1562 1563func (*awsRestxml_deserializeOpDeleteBucketPolicy) ID() string { 1564 return "OperationDeserializer" 1565} 1566 1567func (m *awsRestxml_deserializeOpDeleteBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1568 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1569) { 1570 out, metadata, err = next.HandleDeserialize(ctx, in) 1571 if err != nil { 1572 return out, metadata, err 1573 } 1574 1575 response, ok := out.RawResponse.(*smithyhttp.Response) 1576 if !ok { 1577 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1578 } 1579 1580 if response.StatusCode < 200 || response.StatusCode >= 300 { 1581 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketPolicy(response, &metadata) 1582 } 1583 output := &DeleteBucketPolicyOutput{} 1584 out.Result = output 1585 1586 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1587 return out, metadata, &smithy.DeserializationError{ 1588 Err: fmt.Errorf("failed to discard response body, %w", err), 1589 } 1590 } 1591 1592 return out, metadata, err 1593} 1594 1595func awsRestxml_deserializeOpErrorDeleteBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1596 var errorBuffer bytes.Buffer 1597 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1598 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1599 } 1600 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1601 1602 errorCode := "UnknownError" 1603 errorMessage := errorCode 1604 1605 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1606 UseStatusCode: true, StatusCode: response.StatusCode, 1607 }) 1608 if err != nil { 1609 return err 1610 } 1611 if hostID := errorComponents.HostID; len(hostID) != 0 { 1612 s3shared.SetHostIDMetadata(metadata, hostID) 1613 } 1614 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1615 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1616 } 1617 if len(errorComponents.Code) != 0 { 1618 errorCode = errorComponents.Code 1619 } 1620 if len(errorComponents.Message) != 0 { 1621 errorMessage = errorComponents.Message 1622 } 1623 errorBody.Seek(0, io.SeekStart) 1624 switch { 1625 default: 1626 genericError := &smithy.GenericAPIError{ 1627 Code: errorCode, 1628 Message: errorMessage, 1629 } 1630 return genericError 1631 1632 } 1633} 1634 1635type awsRestxml_deserializeOpDeleteBucketReplication struct { 1636} 1637 1638func (*awsRestxml_deserializeOpDeleteBucketReplication) ID() string { 1639 return "OperationDeserializer" 1640} 1641 1642func (m *awsRestxml_deserializeOpDeleteBucketReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1643 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1644) { 1645 out, metadata, err = next.HandleDeserialize(ctx, in) 1646 if err != nil { 1647 return out, metadata, err 1648 } 1649 1650 response, ok := out.RawResponse.(*smithyhttp.Response) 1651 if !ok { 1652 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1653 } 1654 1655 if response.StatusCode < 200 || response.StatusCode >= 300 { 1656 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketReplication(response, &metadata) 1657 } 1658 output := &DeleteBucketReplicationOutput{} 1659 out.Result = output 1660 1661 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1662 return out, metadata, &smithy.DeserializationError{ 1663 Err: fmt.Errorf("failed to discard response body, %w", err), 1664 } 1665 } 1666 1667 return out, metadata, err 1668} 1669 1670func awsRestxml_deserializeOpErrorDeleteBucketReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1671 var errorBuffer bytes.Buffer 1672 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1673 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1674 } 1675 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1676 1677 errorCode := "UnknownError" 1678 errorMessage := errorCode 1679 1680 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1681 UseStatusCode: true, StatusCode: response.StatusCode, 1682 }) 1683 if err != nil { 1684 return err 1685 } 1686 if hostID := errorComponents.HostID; len(hostID) != 0 { 1687 s3shared.SetHostIDMetadata(metadata, hostID) 1688 } 1689 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1690 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1691 } 1692 if len(errorComponents.Code) != 0 { 1693 errorCode = errorComponents.Code 1694 } 1695 if len(errorComponents.Message) != 0 { 1696 errorMessage = errorComponents.Message 1697 } 1698 errorBody.Seek(0, io.SeekStart) 1699 switch { 1700 default: 1701 genericError := &smithy.GenericAPIError{ 1702 Code: errorCode, 1703 Message: errorMessage, 1704 } 1705 return genericError 1706 1707 } 1708} 1709 1710type awsRestxml_deserializeOpDeleteBucketTagging struct { 1711} 1712 1713func (*awsRestxml_deserializeOpDeleteBucketTagging) ID() string { 1714 return "OperationDeserializer" 1715} 1716 1717func (m *awsRestxml_deserializeOpDeleteBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1718 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1719) { 1720 out, metadata, err = next.HandleDeserialize(ctx, in) 1721 if err != nil { 1722 return out, metadata, err 1723 } 1724 1725 response, ok := out.RawResponse.(*smithyhttp.Response) 1726 if !ok { 1727 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1728 } 1729 1730 if response.StatusCode < 200 || response.StatusCode >= 300 { 1731 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketTagging(response, &metadata) 1732 } 1733 output := &DeleteBucketTaggingOutput{} 1734 out.Result = output 1735 1736 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1737 return out, metadata, &smithy.DeserializationError{ 1738 Err: fmt.Errorf("failed to discard response body, %w", err), 1739 } 1740 } 1741 1742 return out, metadata, err 1743} 1744 1745func awsRestxml_deserializeOpErrorDeleteBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1746 var errorBuffer bytes.Buffer 1747 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1748 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1749 } 1750 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1751 1752 errorCode := "UnknownError" 1753 errorMessage := errorCode 1754 1755 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1756 UseStatusCode: true, StatusCode: response.StatusCode, 1757 }) 1758 if err != nil { 1759 return err 1760 } 1761 if hostID := errorComponents.HostID; len(hostID) != 0 { 1762 s3shared.SetHostIDMetadata(metadata, hostID) 1763 } 1764 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1765 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1766 } 1767 if len(errorComponents.Code) != 0 { 1768 errorCode = errorComponents.Code 1769 } 1770 if len(errorComponents.Message) != 0 { 1771 errorMessage = errorComponents.Message 1772 } 1773 errorBody.Seek(0, io.SeekStart) 1774 switch { 1775 default: 1776 genericError := &smithy.GenericAPIError{ 1777 Code: errorCode, 1778 Message: errorMessage, 1779 } 1780 return genericError 1781 1782 } 1783} 1784 1785type awsRestxml_deserializeOpDeleteBucketWebsite struct { 1786} 1787 1788func (*awsRestxml_deserializeOpDeleteBucketWebsite) ID() string { 1789 return "OperationDeserializer" 1790} 1791 1792func (m *awsRestxml_deserializeOpDeleteBucketWebsite) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1793 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1794) { 1795 out, metadata, err = next.HandleDeserialize(ctx, in) 1796 if err != nil { 1797 return out, metadata, err 1798 } 1799 1800 response, ok := out.RawResponse.(*smithyhttp.Response) 1801 if !ok { 1802 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1803 } 1804 1805 if response.StatusCode < 200 || response.StatusCode >= 300 { 1806 return out, metadata, awsRestxml_deserializeOpErrorDeleteBucketWebsite(response, &metadata) 1807 } 1808 output := &DeleteBucketWebsiteOutput{} 1809 out.Result = output 1810 1811 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1812 return out, metadata, &smithy.DeserializationError{ 1813 Err: fmt.Errorf("failed to discard response body, %w", err), 1814 } 1815 } 1816 1817 return out, metadata, err 1818} 1819 1820func awsRestxml_deserializeOpErrorDeleteBucketWebsite(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1821 var errorBuffer bytes.Buffer 1822 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1823 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1824 } 1825 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1826 1827 errorCode := "UnknownError" 1828 errorMessage := errorCode 1829 1830 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1831 UseStatusCode: true, StatusCode: response.StatusCode, 1832 }) 1833 if err != nil { 1834 return err 1835 } 1836 if hostID := errorComponents.HostID; len(hostID) != 0 { 1837 s3shared.SetHostIDMetadata(metadata, hostID) 1838 } 1839 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1840 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1841 } 1842 if len(errorComponents.Code) != 0 { 1843 errorCode = errorComponents.Code 1844 } 1845 if len(errorComponents.Message) != 0 { 1846 errorMessage = errorComponents.Message 1847 } 1848 errorBody.Seek(0, io.SeekStart) 1849 switch { 1850 default: 1851 genericError := &smithy.GenericAPIError{ 1852 Code: errorCode, 1853 Message: errorMessage, 1854 } 1855 return genericError 1856 1857 } 1858} 1859 1860type awsRestxml_deserializeOpDeleteObject struct { 1861} 1862 1863func (*awsRestxml_deserializeOpDeleteObject) ID() string { 1864 return "OperationDeserializer" 1865} 1866 1867func (m *awsRestxml_deserializeOpDeleteObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1868 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1869) { 1870 out, metadata, err = next.HandleDeserialize(ctx, in) 1871 if err != nil { 1872 return out, metadata, err 1873 } 1874 1875 response, ok := out.RawResponse.(*smithyhttp.Response) 1876 if !ok { 1877 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1878 } 1879 1880 if response.StatusCode < 200 || response.StatusCode >= 300 { 1881 return out, metadata, awsRestxml_deserializeOpErrorDeleteObject(response, &metadata) 1882 } 1883 output := &DeleteObjectOutput{} 1884 out.Result = output 1885 1886 err = awsRestxml_deserializeOpHttpBindingsDeleteObjectOutput(output, response) 1887 if err != nil { 1888 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1889 } 1890 1891 return out, metadata, err 1892} 1893 1894func awsRestxml_deserializeOpErrorDeleteObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1895 var errorBuffer bytes.Buffer 1896 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1897 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1898 } 1899 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1900 1901 errorCode := "UnknownError" 1902 errorMessage := errorCode 1903 1904 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 1905 UseStatusCode: true, StatusCode: response.StatusCode, 1906 }) 1907 if err != nil { 1908 return err 1909 } 1910 if hostID := errorComponents.HostID; len(hostID) != 0 { 1911 s3shared.SetHostIDMetadata(metadata, hostID) 1912 } 1913 if reqID := errorComponents.RequestID; len(reqID) != 0 { 1914 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 1915 } 1916 if len(errorComponents.Code) != 0 { 1917 errorCode = errorComponents.Code 1918 } 1919 if len(errorComponents.Message) != 0 { 1920 errorMessage = errorComponents.Message 1921 } 1922 errorBody.Seek(0, io.SeekStart) 1923 switch { 1924 default: 1925 genericError := &smithy.GenericAPIError{ 1926 Code: errorCode, 1927 Message: errorMessage, 1928 } 1929 return genericError 1930 1931 } 1932} 1933 1934func awsRestxml_deserializeOpHttpBindingsDeleteObjectOutput(v *DeleteObjectOutput, response *smithyhttp.Response) error { 1935 if v == nil { 1936 return fmt.Errorf("unsupported deserialization for nil %T", v) 1937 } 1938 1939 if headerValues := response.Header.Values("x-amz-delete-marker"); len(headerValues) != 0 { 1940 headerValues[0] = strings.TrimSpace(headerValues[0]) 1941 vv, err := strconv.ParseBool(headerValues[0]) 1942 if err != nil { 1943 return err 1944 } 1945 v.DeleteMarker = vv 1946 } 1947 1948 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 1949 headerValues[0] = strings.TrimSpace(headerValues[0]) 1950 v.RequestCharged = types.RequestCharged(headerValues[0]) 1951 } 1952 1953 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 1954 headerValues[0] = strings.TrimSpace(headerValues[0]) 1955 v.VersionId = ptr.String(headerValues[0]) 1956 } 1957 1958 return nil 1959} 1960 1961type awsRestxml_deserializeOpDeleteObjects struct { 1962} 1963 1964func (*awsRestxml_deserializeOpDeleteObjects) ID() string { 1965 return "OperationDeserializer" 1966} 1967 1968func (m *awsRestxml_deserializeOpDeleteObjects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1969 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1970) { 1971 out, metadata, err = next.HandleDeserialize(ctx, in) 1972 if err != nil { 1973 return out, metadata, err 1974 } 1975 1976 response, ok := out.RawResponse.(*smithyhttp.Response) 1977 if !ok { 1978 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1979 } 1980 1981 if response.StatusCode < 200 || response.StatusCode >= 300 { 1982 return out, metadata, awsRestxml_deserializeOpErrorDeleteObjects(response, &metadata) 1983 } 1984 output := &DeleteObjectsOutput{} 1985 out.Result = output 1986 1987 err = awsRestxml_deserializeOpHttpBindingsDeleteObjectsOutput(output, response) 1988 if err != nil { 1989 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 1990 } 1991 1992 var buff [1024]byte 1993 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1994 body := io.TeeReader(response.Body, ringBuffer) 1995 rootDecoder := xml.NewDecoder(body) 1996 t, err := smithyxml.FetchRootElement(rootDecoder) 1997 if err == io.EOF { 1998 return out, metadata, nil 1999 } 2000 if err != nil { 2001 var snapshot bytes.Buffer 2002 io.Copy(&snapshot, ringBuffer) 2003 return out, metadata, &smithy.DeserializationError{ 2004 Err: fmt.Errorf("failed to decode response body, %w", err), 2005 Snapshot: snapshot.Bytes(), 2006 } 2007 } 2008 2009 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2010 err = awsRestxml_deserializeOpDocumentDeleteObjectsOutput(&output, decoder) 2011 if err != nil { 2012 var snapshot bytes.Buffer 2013 io.Copy(&snapshot, ringBuffer) 2014 return out, metadata, &smithy.DeserializationError{ 2015 Err: fmt.Errorf("failed to decode response body, %w", err), 2016 Snapshot: snapshot.Bytes(), 2017 } 2018 } 2019 2020 return out, metadata, err 2021} 2022 2023func awsRestxml_deserializeOpErrorDeleteObjects(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2024 var errorBuffer bytes.Buffer 2025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2027 } 2028 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2029 2030 errorCode := "UnknownError" 2031 errorMessage := errorCode 2032 2033 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2034 UseStatusCode: true, StatusCode: response.StatusCode, 2035 }) 2036 if err != nil { 2037 return err 2038 } 2039 if hostID := errorComponents.HostID; len(hostID) != 0 { 2040 s3shared.SetHostIDMetadata(metadata, hostID) 2041 } 2042 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2043 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2044 } 2045 if len(errorComponents.Code) != 0 { 2046 errorCode = errorComponents.Code 2047 } 2048 if len(errorComponents.Message) != 0 { 2049 errorMessage = errorComponents.Message 2050 } 2051 errorBody.Seek(0, io.SeekStart) 2052 switch { 2053 default: 2054 genericError := &smithy.GenericAPIError{ 2055 Code: errorCode, 2056 Message: errorMessage, 2057 } 2058 return genericError 2059 2060 } 2061} 2062 2063func awsRestxml_deserializeOpHttpBindingsDeleteObjectsOutput(v *DeleteObjectsOutput, response *smithyhttp.Response) error { 2064 if v == nil { 2065 return fmt.Errorf("unsupported deserialization for nil %T", v) 2066 } 2067 2068 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 2069 headerValues[0] = strings.TrimSpace(headerValues[0]) 2070 v.RequestCharged = types.RequestCharged(headerValues[0]) 2071 } 2072 2073 return nil 2074} 2075func awsRestxml_deserializeOpDocumentDeleteObjectsOutput(v **DeleteObjectsOutput, decoder smithyxml.NodeDecoder) error { 2076 if v == nil { 2077 return fmt.Errorf("unexpected nil of type %T", v) 2078 } 2079 var sv *DeleteObjectsOutput 2080 if *v == nil { 2081 sv = &DeleteObjectsOutput{} 2082 } else { 2083 sv = *v 2084 } 2085 2086 for { 2087 t, done, err := decoder.Token() 2088 if err != nil { 2089 return err 2090 } 2091 if done { 2092 break 2093 } 2094 originalDecoder := decoder 2095 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2096 switch { 2097 case strings.EqualFold("Deleted", t.Name.Local): 2098 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2099 if err := awsRestxml_deserializeDocumentDeletedObjectsUnwrapped(&sv.Deleted, nodeDecoder); err != nil { 2100 return err 2101 } 2102 2103 case strings.EqualFold("Error", t.Name.Local): 2104 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2105 if err := awsRestxml_deserializeDocumentErrorsUnwrapped(&sv.Errors, nodeDecoder); err != nil { 2106 return err 2107 } 2108 2109 default: 2110 // Do nothing and ignore the unexpected tag element 2111 err = decoder.Decoder.Skip() 2112 if err != nil { 2113 return err 2114 } 2115 2116 } 2117 decoder = originalDecoder 2118 } 2119 *v = sv 2120 return nil 2121} 2122 2123type awsRestxml_deserializeOpDeleteObjectTagging struct { 2124} 2125 2126func (*awsRestxml_deserializeOpDeleteObjectTagging) ID() string { 2127 return "OperationDeserializer" 2128} 2129 2130func (m *awsRestxml_deserializeOpDeleteObjectTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2131 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2132) { 2133 out, metadata, err = next.HandleDeserialize(ctx, in) 2134 if err != nil { 2135 return out, metadata, err 2136 } 2137 2138 response, ok := out.RawResponse.(*smithyhttp.Response) 2139 if !ok { 2140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2141 } 2142 2143 if response.StatusCode < 200 || response.StatusCode >= 300 { 2144 return out, metadata, awsRestxml_deserializeOpErrorDeleteObjectTagging(response, &metadata) 2145 } 2146 output := &DeleteObjectTaggingOutput{} 2147 out.Result = output 2148 2149 err = awsRestxml_deserializeOpHttpBindingsDeleteObjectTaggingOutput(output, response) 2150 if err != nil { 2151 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 2152 } 2153 2154 return out, metadata, err 2155} 2156 2157func awsRestxml_deserializeOpErrorDeleteObjectTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2158 var errorBuffer bytes.Buffer 2159 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2160 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2161 } 2162 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2163 2164 errorCode := "UnknownError" 2165 errorMessage := errorCode 2166 2167 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2168 UseStatusCode: true, StatusCode: response.StatusCode, 2169 }) 2170 if err != nil { 2171 return err 2172 } 2173 if hostID := errorComponents.HostID; len(hostID) != 0 { 2174 s3shared.SetHostIDMetadata(metadata, hostID) 2175 } 2176 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2177 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2178 } 2179 if len(errorComponents.Code) != 0 { 2180 errorCode = errorComponents.Code 2181 } 2182 if len(errorComponents.Message) != 0 { 2183 errorMessage = errorComponents.Message 2184 } 2185 errorBody.Seek(0, io.SeekStart) 2186 switch { 2187 default: 2188 genericError := &smithy.GenericAPIError{ 2189 Code: errorCode, 2190 Message: errorMessage, 2191 } 2192 return genericError 2193 2194 } 2195} 2196 2197func awsRestxml_deserializeOpHttpBindingsDeleteObjectTaggingOutput(v *DeleteObjectTaggingOutput, response *smithyhttp.Response) error { 2198 if v == nil { 2199 return fmt.Errorf("unsupported deserialization for nil %T", v) 2200 } 2201 2202 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 2203 headerValues[0] = strings.TrimSpace(headerValues[0]) 2204 v.VersionId = ptr.String(headerValues[0]) 2205 } 2206 2207 return nil 2208} 2209 2210type awsRestxml_deserializeOpDeletePublicAccessBlock struct { 2211} 2212 2213func (*awsRestxml_deserializeOpDeletePublicAccessBlock) ID() string { 2214 return "OperationDeserializer" 2215} 2216 2217func (m *awsRestxml_deserializeOpDeletePublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2218 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2219) { 2220 out, metadata, err = next.HandleDeserialize(ctx, in) 2221 if err != nil { 2222 return out, metadata, err 2223 } 2224 2225 response, ok := out.RawResponse.(*smithyhttp.Response) 2226 if !ok { 2227 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2228 } 2229 2230 if response.StatusCode < 200 || response.StatusCode >= 300 { 2231 return out, metadata, awsRestxml_deserializeOpErrorDeletePublicAccessBlock(response, &metadata) 2232 } 2233 output := &DeletePublicAccessBlockOutput{} 2234 out.Result = output 2235 2236 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2237 return out, metadata, &smithy.DeserializationError{ 2238 Err: fmt.Errorf("failed to discard response body, %w", err), 2239 } 2240 } 2241 2242 return out, metadata, err 2243} 2244 2245func awsRestxml_deserializeOpErrorDeletePublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2246 var errorBuffer bytes.Buffer 2247 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2248 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2249 } 2250 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2251 2252 errorCode := "UnknownError" 2253 errorMessage := errorCode 2254 2255 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2256 UseStatusCode: true, StatusCode: response.StatusCode, 2257 }) 2258 if err != nil { 2259 return err 2260 } 2261 if hostID := errorComponents.HostID; len(hostID) != 0 { 2262 s3shared.SetHostIDMetadata(metadata, hostID) 2263 } 2264 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2265 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2266 } 2267 if len(errorComponents.Code) != 0 { 2268 errorCode = errorComponents.Code 2269 } 2270 if len(errorComponents.Message) != 0 { 2271 errorMessage = errorComponents.Message 2272 } 2273 errorBody.Seek(0, io.SeekStart) 2274 switch { 2275 default: 2276 genericError := &smithy.GenericAPIError{ 2277 Code: errorCode, 2278 Message: errorMessage, 2279 } 2280 return genericError 2281 2282 } 2283} 2284 2285type awsRestxml_deserializeOpGetBucketAccelerateConfiguration struct { 2286} 2287 2288func (*awsRestxml_deserializeOpGetBucketAccelerateConfiguration) ID() string { 2289 return "OperationDeserializer" 2290} 2291 2292func (m *awsRestxml_deserializeOpGetBucketAccelerateConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2293 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2294) { 2295 out, metadata, err = next.HandleDeserialize(ctx, in) 2296 if err != nil { 2297 return out, metadata, err 2298 } 2299 2300 response, ok := out.RawResponse.(*smithyhttp.Response) 2301 if !ok { 2302 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2303 } 2304 2305 if response.StatusCode < 200 || response.StatusCode >= 300 { 2306 return out, metadata, awsRestxml_deserializeOpErrorGetBucketAccelerateConfiguration(response, &metadata) 2307 } 2308 output := &GetBucketAccelerateConfigurationOutput{} 2309 out.Result = output 2310 2311 var buff [1024]byte 2312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2313 body := io.TeeReader(response.Body, ringBuffer) 2314 rootDecoder := xml.NewDecoder(body) 2315 t, err := smithyxml.FetchRootElement(rootDecoder) 2316 if err == io.EOF { 2317 return out, metadata, nil 2318 } 2319 if err != nil { 2320 var snapshot bytes.Buffer 2321 io.Copy(&snapshot, ringBuffer) 2322 return out, metadata, &smithy.DeserializationError{ 2323 Err: fmt.Errorf("failed to decode response body, %w", err), 2324 Snapshot: snapshot.Bytes(), 2325 } 2326 } 2327 2328 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2329 err = awsRestxml_deserializeOpDocumentGetBucketAccelerateConfigurationOutput(&output, decoder) 2330 if err != nil { 2331 var snapshot bytes.Buffer 2332 io.Copy(&snapshot, ringBuffer) 2333 return out, metadata, &smithy.DeserializationError{ 2334 Err: fmt.Errorf("failed to decode response body, %w", err), 2335 Snapshot: snapshot.Bytes(), 2336 } 2337 } 2338 2339 return out, metadata, err 2340} 2341 2342func awsRestxml_deserializeOpErrorGetBucketAccelerateConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2343 var errorBuffer bytes.Buffer 2344 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2345 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2346 } 2347 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2348 2349 errorCode := "UnknownError" 2350 errorMessage := errorCode 2351 2352 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2353 UseStatusCode: true, StatusCode: response.StatusCode, 2354 }) 2355 if err != nil { 2356 return err 2357 } 2358 if hostID := errorComponents.HostID; len(hostID) != 0 { 2359 s3shared.SetHostIDMetadata(metadata, hostID) 2360 } 2361 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2362 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2363 } 2364 if len(errorComponents.Code) != 0 { 2365 errorCode = errorComponents.Code 2366 } 2367 if len(errorComponents.Message) != 0 { 2368 errorMessage = errorComponents.Message 2369 } 2370 errorBody.Seek(0, io.SeekStart) 2371 switch { 2372 default: 2373 genericError := &smithy.GenericAPIError{ 2374 Code: errorCode, 2375 Message: errorMessage, 2376 } 2377 return genericError 2378 2379 } 2380} 2381 2382func awsRestxml_deserializeOpDocumentGetBucketAccelerateConfigurationOutput(v **GetBucketAccelerateConfigurationOutput, decoder smithyxml.NodeDecoder) error { 2383 if v == nil { 2384 return fmt.Errorf("unexpected nil of type %T", v) 2385 } 2386 var sv *GetBucketAccelerateConfigurationOutput 2387 if *v == nil { 2388 sv = &GetBucketAccelerateConfigurationOutput{} 2389 } else { 2390 sv = *v 2391 } 2392 2393 for { 2394 t, done, err := decoder.Token() 2395 if err != nil { 2396 return err 2397 } 2398 if done { 2399 break 2400 } 2401 originalDecoder := decoder 2402 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2403 switch { 2404 case strings.EqualFold("Status", t.Name.Local): 2405 val, err := decoder.Value() 2406 if err != nil { 2407 return err 2408 } 2409 if val == nil { 2410 break 2411 } 2412 { 2413 xtv := string(val) 2414 sv.Status = types.BucketAccelerateStatus(xtv) 2415 } 2416 2417 default: 2418 // Do nothing and ignore the unexpected tag element 2419 err = decoder.Decoder.Skip() 2420 if err != nil { 2421 return err 2422 } 2423 2424 } 2425 decoder = originalDecoder 2426 } 2427 *v = sv 2428 return nil 2429} 2430 2431type awsRestxml_deserializeOpGetBucketAcl struct { 2432} 2433 2434func (*awsRestxml_deserializeOpGetBucketAcl) ID() string { 2435 return "OperationDeserializer" 2436} 2437 2438func (m *awsRestxml_deserializeOpGetBucketAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2439 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2440) { 2441 out, metadata, err = next.HandleDeserialize(ctx, in) 2442 if err != nil { 2443 return out, metadata, err 2444 } 2445 2446 response, ok := out.RawResponse.(*smithyhttp.Response) 2447 if !ok { 2448 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2449 } 2450 2451 if response.StatusCode < 200 || response.StatusCode >= 300 { 2452 return out, metadata, awsRestxml_deserializeOpErrorGetBucketAcl(response, &metadata) 2453 } 2454 output := &GetBucketAclOutput{} 2455 out.Result = output 2456 2457 var buff [1024]byte 2458 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2459 body := io.TeeReader(response.Body, ringBuffer) 2460 rootDecoder := xml.NewDecoder(body) 2461 t, err := smithyxml.FetchRootElement(rootDecoder) 2462 if err == io.EOF { 2463 return out, metadata, nil 2464 } 2465 if err != nil { 2466 var snapshot bytes.Buffer 2467 io.Copy(&snapshot, ringBuffer) 2468 return out, metadata, &smithy.DeserializationError{ 2469 Err: fmt.Errorf("failed to decode response body, %w", err), 2470 Snapshot: snapshot.Bytes(), 2471 } 2472 } 2473 2474 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2475 err = awsRestxml_deserializeOpDocumentGetBucketAclOutput(&output, decoder) 2476 if err != nil { 2477 var snapshot bytes.Buffer 2478 io.Copy(&snapshot, ringBuffer) 2479 return out, metadata, &smithy.DeserializationError{ 2480 Err: fmt.Errorf("failed to decode response body, %w", err), 2481 Snapshot: snapshot.Bytes(), 2482 } 2483 } 2484 2485 return out, metadata, err 2486} 2487 2488func awsRestxml_deserializeOpErrorGetBucketAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2489 var errorBuffer bytes.Buffer 2490 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2491 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2492 } 2493 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2494 2495 errorCode := "UnknownError" 2496 errorMessage := errorCode 2497 2498 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2499 UseStatusCode: true, StatusCode: response.StatusCode, 2500 }) 2501 if err != nil { 2502 return err 2503 } 2504 if hostID := errorComponents.HostID; len(hostID) != 0 { 2505 s3shared.SetHostIDMetadata(metadata, hostID) 2506 } 2507 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2508 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2509 } 2510 if len(errorComponents.Code) != 0 { 2511 errorCode = errorComponents.Code 2512 } 2513 if len(errorComponents.Message) != 0 { 2514 errorMessage = errorComponents.Message 2515 } 2516 errorBody.Seek(0, io.SeekStart) 2517 switch { 2518 default: 2519 genericError := &smithy.GenericAPIError{ 2520 Code: errorCode, 2521 Message: errorMessage, 2522 } 2523 return genericError 2524 2525 } 2526} 2527 2528func awsRestxml_deserializeOpDocumentGetBucketAclOutput(v **GetBucketAclOutput, decoder smithyxml.NodeDecoder) error { 2529 if v == nil { 2530 return fmt.Errorf("unexpected nil of type %T", v) 2531 } 2532 var sv *GetBucketAclOutput 2533 if *v == nil { 2534 sv = &GetBucketAclOutput{} 2535 } else { 2536 sv = *v 2537 } 2538 2539 for { 2540 t, done, err := decoder.Token() 2541 if err != nil { 2542 return err 2543 } 2544 if done { 2545 break 2546 } 2547 originalDecoder := decoder 2548 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2549 switch { 2550 case strings.EqualFold("AccessControlList", t.Name.Local): 2551 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2552 if err := awsRestxml_deserializeDocumentGrants(&sv.Grants, nodeDecoder); err != nil { 2553 return err 2554 } 2555 2556 case strings.EqualFold("Owner", t.Name.Local): 2557 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2558 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 2559 return err 2560 } 2561 2562 default: 2563 // Do nothing and ignore the unexpected tag element 2564 err = decoder.Decoder.Skip() 2565 if err != nil { 2566 return err 2567 } 2568 2569 } 2570 decoder = originalDecoder 2571 } 2572 *v = sv 2573 return nil 2574} 2575 2576type awsRestxml_deserializeOpGetBucketAnalyticsConfiguration struct { 2577} 2578 2579func (*awsRestxml_deserializeOpGetBucketAnalyticsConfiguration) ID() string { 2580 return "OperationDeserializer" 2581} 2582 2583func (m *awsRestxml_deserializeOpGetBucketAnalyticsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2584 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2585) { 2586 out, metadata, err = next.HandleDeserialize(ctx, in) 2587 if err != nil { 2588 return out, metadata, err 2589 } 2590 2591 response, ok := out.RawResponse.(*smithyhttp.Response) 2592 if !ok { 2593 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2594 } 2595 2596 if response.StatusCode < 200 || response.StatusCode >= 300 { 2597 return out, metadata, awsRestxml_deserializeOpErrorGetBucketAnalyticsConfiguration(response, &metadata) 2598 } 2599 output := &GetBucketAnalyticsConfigurationOutput{} 2600 out.Result = output 2601 2602 var buff [1024]byte 2603 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2604 body := io.TeeReader(response.Body, ringBuffer) 2605 rootDecoder := xml.NewDecoder(body) 2606 t, err := smithyxml.FetchRootElement(rootDecoder) 2607 if err == io.EOF { 2608 return out, metadata, nil 2609 } 2610 if err != nil { 2611 var snapshot bytes.Buffer 2612 io.Copy(&snapshot, ringBuffer) 2613 return out, metadata, &smithy.DeserializationError{ 2614 Err: fmt.Errorf("failed to decode response body, %w", err), 2615 Snapshot: snapshot.Bytes(), 2616 } 2617 } 2618 2619 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2620 err = awsRestxml_deserializeDocumentAnalyticsConfiguration(&output.AnalyticsConfiguration, decoder) 2621 if err != nil { 2622 var snapshot bytes.Buffer 2623 io.Copy(&snapshot, ringBuffer) 2624 return out, metadata, &smithy.DeserializationError{ 2625 Err: fmt.Errorf("failed to decode response body, %w", err), 2626 Snapshot: snapshot.Bytes(), 2627 } 2628 } 2629 2630 return out, metadata, err 2631} 2632 2633func awsRestxml_deserializeOpErrorGetBucketAnalyticsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2634 var errorBuffer bytes.Buffer 2635 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2636 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2637 } 2638 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2639 2640 errorCode := "UnknownError" 2641 errorMessage := errorCode 2642 2643 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2644 UseStatusCode: true, StatusCode: response.StatusCode, 2645 }) 2646 if err != nil { 2647 return err 2648 } 2649 if hostID := errorComponents.HostID; len(hostID) != 0 { 2650 s3shared.SetHostIDMetadata(metadata, hostID) 2651 } 2652 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2653 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2654 } 2655 if len(errorComponents.Code) != 0 { 2656 errorCode = errorComponents.Code 2657 } 2658 if len(errorComponents.Message) != 0 { 2659 errorMessage = errorComponents.Message 2660 } 2661 errorBody.Seek(0, io.SeekStart) 2662 switch { 2663 default: 2664 genericError := &smithy.GenericAPIError{ 2665 Code: errorCode, 2666 Message: errorMessage, 2667 } 2668 return genericError 2669 2670 } 2671} 2672 2673func awsRestxml_deserializeOpDocumentGetBucketAnalyticsConfigurationOutput(v **GetBucketAnalyticsConfigurationOutput, decoder smithyxml.NodeDecoder) error { 2674 if v == nil { 2675 return fmt.Errorf("unexpected nil of type %T", v) 2676 } 2677 var sv *GetBucketAnalyticsConfigurationOutput 2678 if *v == nil { 2679 sv = &GetBucketAnalyticsConfigurationOutput{} 2680 } else { 2681 sv = *v 2682 } 2683 2684 for { 2685 t, done, err := decoder.Token() 2686 if err != nil { 2687 return err 2688 } 2689 if done { 2690 break 2691 } 2692 originalDecoder := decoder 2693 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2694 switch { 2695 case strings.EqualFold("AnalyticsConfiguration", t.Name.Local): 2696 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2697 if err := awsRestxml_deserializeDocumentAnalyticsConfiguration(&sv.AnalyticsConfiguration, nodeDecoder); err != nil { 2698 return err 2699 } 2700 2701 default: 2702 // Do nothing and ignore the unexpected tag element 2703 err = decoder.Decoder.Skip() 2704 if err != nil { 2705 return err 2706 } 2707 2708 } 2709 decoder = originalDecoder 2710 } 2711 *v = sv 2712 return nil 2713} 2714 2715type awsRestxml_deserializeOpGetBucketCors struct { 2716} 2717 2718func (*awsRestxml_deserializeOpGetBucketCors) ID() string { 2719 return "OperationDeserializer" 2720} 2721 2722func (m *awsRestxml_deserializeOpGetBucketCors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2723 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2724) { 2725 out, metadata, err = next.HandleDeserialize(ctx, in) 2726 if err != nil { 2727 return out, metadata, err 2728 } 2729 2730 response, ok := out.RawResponse.(*smithyhttp.Response) 2731 if !ok { 2732 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2733 } 2734 2735 if response.StatusCode < 200 || response.StatusCode >= 300 { 2736 return out, metadata, awsRestxml_deserializeOpErrorGetBucketCors(response, &metadata) 2737 } 2738 output := &GetBucketCorsOutput{} 2739 out.Result = output 2740 2741 var buff [1024]byte 2742 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2743 body := io.TeeReader(response.Body, ringBuffer) 2744 rootDecoder := xml.NewDecoder(body) 2745 t, err := smithyxml.FetchRootElement(rootDecoder) 2746 if err == io.EOF { 2747 return out, metadata, nil 2748 } 2749 if err != nil { 2750 var snapshot bytes.Buffer 2751 io.Copy(&snapshot, ringBuffer) 2752 return out, metadata, &smithy.DeserializationError{ 2753 Err: fmt.Errorf("failed to decode response body, %w", err), 2754 Snapshot: snapshot.Bytes(), 2755 } 2756 } 2757 2758 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2759 err = awsRestxml_deserializeOpDocumentGetBucketCorsOutput(&output, decoder) 2760 if err != nil { 2761 var snapshot bytes.Buffer 2762 io.Copy(&snapshot, ringBuffer) 2763 return out, metadata, &smithy.DeserializationError{ 2764 Err: fmt.Errorf("failed to decode response body, %w", err), 2765 Snapshot: snapshot.Bytes(), 2766 } 2767 } 2768 2769 return out, metadata, err 2770} 2771 2772func awsRestxml_deserializeOpErrorGetBucketCors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2773 var errorBuffer bytes.Buffer 2774 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2775 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2776 } 2777 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2778 2779 errorCode := "UnknownError" 2780 errorMessage := errorCode 2781 2782 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2783 UseStatusCode: true, StatusCode: response.StatusCode, 2784 }) 2785 if err != nil { 2786 return err 2787 } 2788 if hostID := errorComponents.HostID; len(hostID) != 0 { 2789 s3shared.SetHostIDMetadata(metadata, hostID) 2790 } 2791 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2792 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2793 } 2794 if len(errorComponents.Code) != 0 { 2795 errorCode = errorComponents.Code 2796 } 2797 if len(errorComponents.Message) != 0 { 2798 errorMessage = errorComponents.Message 2799 } 2800 errorBody.Seek(0, io.SeekStart) 2801 switch { 2802 default: 2803 genericError := &smithy.GenericAPIError{ 2804 Code: errorCode, 2805 Message: errorMessage, 2806 } 2807 return genericError 2808 2809 } 2810} 2811 2812func awsRestxml_deserializeOpDocumentGetBucketCorsOutput(v **GetBucketCorsOutput, decoder smithyxml.NodeDecoder) error { 2813 if v == nil { 2814 return fmt.Errorf("unexpected nil of type %T", v) 2815 } 2816 var sv *GetBucketCorsOutput 2817 if *v == nil { 2818 sv = &GetBucketCorsOutput{} 2819 } else { 2820 sv = *v 2821 } 2822 2823 for { 2824 t, done, err := decoder.Token() 2825 if err != nil { 2826 return err 2827 } 2828 if done { 2829 break 2830 } 2831 originalDecoder := decoder 2832 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2833 switch { 2834 case strings.EqualFold("CORSRule", t.Name.Local): 2835 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2836 if err := awsRestxml_deserializeDocumentCORSRulesUnwrapped(&sv.CORSRules, nodeDecoder); err != nil { 2837 return err 2838 } 2839 2840 default: 2841 // Do nothing and ignore the unexpected tag element 2842 err = decoder.Decoder.Skip() 2843 if err != nil { 2844 return err 2845 } 2846 2847 } 2848 decoder = originalDecoder 2849 } 2850 *v = sv 2851 return nil 2852} 2853 2854type awsRestxml_deserializeOpGetBucketEncryption struct { 2855} 2856 2857func (*awsRestxml_deserializeOpGetBucketEncryption) ID() string { 2858 return "OperationDeserializer" 2859} 2860 2861func (m *awsRestxml_deserializeOpGetBucketEncryption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2862 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2863) { 2864 out, metadata, err = next.HandleDeserialize(ctx, in) 2865 if err != nil { 2866 return out, metadata, err 2867 } 2868 2869 response, ok := out.RawResponse.(*smithyhttp.Response) 2870 if !ok { 2871 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2872 } 2873 2874 if response.StatusCode < 200 || response.StatusCode >= 300 { 2875 return out, metadata, awsRestxml_deserializeOpErrorGetBucketEncryption(response, &metadata) 2876 } 2877 output := &GetBucketEncryptionOutput{} 2878 out.Result = output 2879 2880 var buff [1024]byte 2881 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2882 body := io.TeeReader(response.Body, ringBuffer) 2883 rootDecoder := xml.NewDecoder(body) 2884 t, err := smithyxml.FetchRootElement(rootDecoder) 2885 if err == io.EOF { 2886 return out, metadata, nil 2887 } 2888 if err != nil { 2889 var snapshot bytes.Buffer 2890 io.Copy(&snapshot, ringBuffer) 2891 return out, metadata, &smithy.DeserializationError{ 2892 Err: fmt.Errorf("failed to decode response body, %w", err), 2893 Snapshot: snapshot.Bytes(), 2894 } 2895 } 2896 2897 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 2898 err = awsRestxml_deserializeDocumentServerSideEncryptionConfiguration(&output.ServerSideEncryptionConfiguration, decoder) 2899 if err != nil { 2900 var snapshot bytes.Buffer 2901 io.Copy(&snapshot, ringBuffer) 2902 return out, metadata, &smithy.DeserializationError{ 2903 Err: fmt.Errorf("failed to decode response body, %w", err), 2904 Snapshot: snapshot.Bytes(), 2905 } 2906 } 2907 2908 return out, metadata, err 2909} 2910 2911func awsRestxml_deserializeOpErrorGetBucketEncryption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2912 var errorBuffer bytes.Buffer 2913 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2914 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2915 } 2916 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2917 2918 errorCode := "UnknownError" 2919 errorMessage := errorCode 2920 2921 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 2922 UseStatusCode: true, StatusCode: response.StatusCode, 2923 }) 2924 if err != nil { 2925 return err 2926 } 2927 if hostID := errorComponents.HostID; len(hostID) != 0 { 2928 s3shared.SetHostIDMetadata(metadata, hostID) 2929 } 2930 if reqID := errorComponents.RequestID; len(reqID) != 0 { 2931 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 2932 } 2933 if len(errorComponents.Code) != 0 { 2934 errorCode = errorComponents.Code 2935 } 2936 if len(errorComponents.Message) != 0 { 2937 errorMessage = errorComponents.Message 2938 } 2939 errorBody.Seek(0, io.SeekStart) 2940 switch { 2941 default: 2942 genericError := &smithy.GenericAPIError{ 2943 Code: errorCode, 2944 Message: errorMessage, 2945 } 2946 return genericError 2947 2948 } 2949} 2950 2951func awsRestxml_deserializeOpDocumentGetBucketEncryptionOutput(v **GetBucketEncryptionOutput, decoder smithyxml.NodeDecoder) error { 2952 if v == nil { 2953 return fmt.Errorf("unexpected nil of type %T", v) 2954 } 2955 var sv *GetBucketEncryptionOutput 2956 if *v == nil { 2957 sv = &GetBucketEncryptionOutput{} 2958 } else { 2959 sv = *v 2960 } 2961 2962 for { 2963 t, done, err := decoder.Token() 2964 if err != nil { 2965 return err 2966 } 2967 if done { 2968 break 2969 } 2970 originalDecoder := decoder 2971 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 2972 switch { 2973 case strings.EqualFold("ServerSideEncryptionConfiguration", t.Name.Local): 2974 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 2975 if err := awsRestxml_deserializeDocumentServerSideEncryptionConfiguration(&sv.ServerSideEncryptionConfiguration, nodeDecoder); err != nil { 2976 return err 2977 } 2978 2979 default: 2980 // Do nothing and ignore the unexpected tag element 2981 err = decoder.Decoder.Skip() 2982 if err != nil { 2983 return err 2984 } 2985 2986 } 2987 decoder = originalDecoder 2988 } 2989 *v = sv 2990 return nil 2991} 2992 2993type awsRestxml_deserializeOpGetBucketIntelligentTieringConfiguration struct { 2994} 2995 2996func (*awsRestxml_deserializeOpGetBucketIntelligentTieringConfiguration) ID() string { 2997 return "OperationDeserializer" 2998} 2999 3000func (m *awsRestxml_deserializeOpGetBucketIntelligentTieringConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3001 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3002) { 3003 out, metadata, err = next.HandleDeserialize(ctx, in) 3004 if err != nil { 3005 return out, metadata, err 3006 } 3007 3008 response, ok := out.RawResponse.(*smithyhttp.Response) 3009 if !ok { 3010 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3011 } 3012 3013 if response.StatusCode < 200 || response.StatusCode >= 300 { 3014 return out, metadata, awsRestxml_deserializeOpErrorGetBucketIntelligentTieringConfiguration(response, &metadata) 3015 } 3016 output := &GetBucketIntelligentTieringConfigurationOutput{} 3017 out.Result = output 3018 3019 var buff [1024]byte 3020 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3021 body := io.TeeReader(response.Body, ringBuffer) 3022 rootDecoder := xml.NewDecoder(body) 3023 t, err := smithyxml.FetchRootElement(rootDecoder) 3024 if err == io.EOF { 3025 return out, metadata, nil 3026 } 3027 if err != nil { 3028 var snapshot bytes.Buffer 3029 io.Copy(&snapshot, ringBuffer) 3030 return out, metadata, &smithy.DeserializationError{ 3031 Err: fmt.Errorf("failed to decode response body, %w", err), 3032 Snapshot: snapshot.Bytes(), 3033 } 3034 } 3035 3036 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3037 err = awsRestxml_deserializeDocumentIntelligentTieringConfiguration(&output.IntelligentTieringConfiguration, decoder) 3038 if err != nil { 3039 var snapshot bytes.Buffer 3040 io.Copy(&snapshot, ringBuffer) 3041 return out, metadata, &smithy.DeserializationError{ 3042 Err: fmt.Errorf("failed to decode response body, %w", err), 3043 Snapshot: snapshot.Bytes(), 3044 } 3045 } 3046 3047 return out, metadata, err 3048} 3049 3050func awsRestxml_deserializeOpErrorGetBucketIntelligentTieringConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3051 var errorBuffer bytes.Buffer 3052 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3053 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3054 } 3055 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3056 3057 errorCode := "UnknownError" 3058 errorMessage := errorCode 3059 3060 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3061 UseStatusCode: true, StatusCode: response.StatusCode, 3062 }) 3063 if err != nil { 3064 return err 3065 } 3066 if hostID := errorComponents.HostID; len(hostID) != 0 { 3067 s3shared.SetHostIDMetadata(metadata, hostID) 3068 } 3069 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3070 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3071 } 3072 if len(errorComponents.Code) != 0 { 3073 errorCode = errorComponents.Code 3074 } 3075 if len(errorComponents.Message) != 0 { 3076 errorMessage = errorComponents.Message 3077 } 3078 errorBody.Seek(0, io.SeekStart) 3079 switch { 3080 default: 3081 genericError := &smithy.GenericAPIError{ 3082 Code: errorCode, 3083 Message: errorMessage, 3084 } 3085 return genericError 3086 3087 } 3088} 3089 3090func awsRestxml_deserializeOpDocumentGetBucketIntelligentTieringConfigurationOutput(v **GetBucketIntelligentTieringConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3091 if v == nil { 3092 return fmt.Errorf("unexpected nil of type %T", v) 3093 } 3094 var sv *GetBucketIntelligentTieringConfigurationOutput 3095 if *v == nil { 3096 sv = &GetBucketIntelligentTieringConfigurationOutput{} 3097 } else { 3098 sv = *v 3099 } 3100 3101 for { 3102 t, done, err := decoder.Token() 3103 if err != nil { 3104 return err 3105 } 3106 if done { 3107 break 3108 } 3109 originalDecoder := decoder 3110 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3111 switch { 3112 case strings.EqualFold("IntelligentTieringConfiguration", t.Name.Local): 3113 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3114 if err := awsRestxml_deserializeDocumentIntelligentTieringConfiguration(&sv.IntelligentTieringConfiguration, nodeDecoder); err != nil { 3115 return err 3116 } 3117 3118 default: 3119 // Do nothing and ignore the unexpected tag element 3120 err = decoder.Decoder.Skip() 3121 if err != nil { 3122 return err 3123 } 3124 3125 } 3126 decoder = originalDecoder 3127 } 3128 *v = sv 3129 return nil 3130} 3131 3132type awsRestxml_deserializeOpGetBucketInventoryConfiguration struct { 3133} 3134 3135func (*awsRestxml_deserializeOpGetBucketInventoryConfiguration) ID() string { 3136 return "OperationDeserializer" 3137} 3138 3139func (m *awsRestxml_deserializeOpGetBucketInventoryConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3140 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3141) { 3142 out, metadata, err = next.HandleDeserialize(ctx, in) 3143 if err != nil { 3144 return out, metadata, err 3145 } 3146 3147 response, ok := out.RawResponse.(*smithyhttp.Response) 3148 if !ok { 3149 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3150 } 3151 3152 if response.StatusCode < 200 || response.StatusCode >= 300 { 3153 return out, metadata, awsRestxml_deserializeOpErrorGetBucketInventoryConfiguration(response, &metadata) 3154 } 3155 output := &GetBucketInventoryConfigurationOutput{} 3156 out.Result = output 3157 3158 var buff [1024]byte 3159 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3160 body := io.TeeReader(response.Body, ringBuffer) 3161 rootDecoder := xml.NewDecoder(body) 3162 t, err := smithyxml.FetchRootElement(rootDecoder) 3163 if err == io.EOF { 3164 return out, metadata, nil 3165 } 3166 if err != nil { 3167 var snapshot bytes.Buffer 3168 io.Copy(&snapshot, ringBuffer) 3169 return out, metadata, &smithy.DeserializationError{ 3170 Err: fmt.Errorf("failed to decode response body, %w", err), 3171 Snapshot: snapshot.Bytes(), 3172 } 3173 } 3174 3175 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3176 err = awsRestxml_deserializeDocumentInventoryConfiguration(&output.InventoryConfiguration, decoder) 3177 if err != nil { 3178 var snapshot bytes.Buffer 3179 io.Copy(&snapshot, ringBuffer) 3180 return out, metadata, &smithy.DeserializationError{ 3181 Err: fmt.Errorf("failed to decode response body, %w", err), 3182 Snapshot: snapshot.Bytes(), 3183 } 3184 } 3185 3186 return out, metadata, err 3187} 3188 3189func awsRestxml_deserializeOpErrorGetBucketInventoryConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3190 var errorBuffer bytes.Buffer 3191 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3192 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3193 } 3194 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3195 3196 errorCode := "UnknownError" 3197 errorMessage := errorCode 3198 3199 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3200 UseStatusCode: true, StatusCode: response.StatusCode, 3201 }) 3202 if err != nil { 3203 return err 3204 } 3205 if hostID := errorComponents.HostID; len(hostID) != 0 { 3206 s3shared.SetHostIDMetadata(metadata, hostID) 3207 } 3208 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3209 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3210 } 3211 if len(errorComponents.Code) != 0 { 3212 errorCode = errorComponents.Code 3213 } 3214 if len(errorComponents.Message) != 0 { 3215 errorMessage = errorComponents.Message 3216 } 3217 errorBody.Seek(0, io.SeekStart) 3218 switch { 3219 default: 3220 genericError := &smithy.GenericAPIError{ 3221 Code: errorCode, 3222 Message: errorMessage, 3223 } 3224 return genericError 3225 3226 } 3227} 3228 3229func awsRestxml_deserializeOpDocumentGetBucketInventoryConfigurationOutput(v **GetBucketInventoryConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3230 if v == nil { 3231 return fmt.Errorf("unexpected nil of type %T", v) 3232 } 3233 var sv *GetBucketInventoryConfigurationOutput 3234 if *v == nil { 3235 sv = &GetBucketInventoryConfigurationOutput{} 3236 } else { 3237 sv = *v 3238 } 3239 3240 for { 3241 t, done, err := decoder.Token() 3242 if err != nil { 3243 return err 3244 } 3245 if done { 3246 break 3247 } 3248 originalDecoder := decoder 3249 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3250 switch { 3251 case strings.EqualFold("InventoryConfiguration", t.Name.Local): 3252 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3253 if err := awsRestxml_deserializeDocumentInventoryConfiguration(&sv.InventoryConfiguration, nodeDecoder); err != nil { 3254 return err 3255 } 3256 3257 default: 3258 // Do nothing and ignore the unexpected tag element 3259 err = decoder.Decoder.Skip() 3260 if err != nil { 3261 return err 3262 } 3263 3264 } 3265 decoder = originalDecoder 3266 } 3267 *v = sv 3268 return nil 3269} 3270 3271type awsRestxml_deserializeOpGetBucketLifecycleConfiguration struct { 3272} 3273 3274func (*awsRestxml_deserializeOpGetBucketLifecycleConfiguration) ID() string { 3275 return "OperationDeserializer" 3276} 3277 3278func (m *awsRestxml_deserializeOpGetBucketLifecycleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3279 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3280) { 3281 out, metadata, err = next.HandleDeserialize(ctx, in) 3282 if err != nil { 3283 return out, metadata, err 3284 } 3285 3286 response, ok := out.RawResponse.(*smithyhttp.Response) 3287 if !ok { 3288 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3289 } 3290 3291 if response.StatusCode < 200 || response.StatusCode >= 300 { 3292 return out, metadata, awsRestxml_deserializeOpErrorGetBucketLifecycleConfiguration(response, &metadata) 3293 } 3294 output := &GetBucketLifecycleConfigurationOutput{} 3295 out.Result = output 3296 3297 var buff [1024]byte 3298 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3299 body := io.TeeReader(response.Body, ringBuffer) 3300 rootDecoder := xml.NewDecoder(body) 3301 t, err := smithyxml.FetchRootElement(rootDecoder) 3302 if err == io.EOF { 3303 return out, metadata, nil 3304 } 3305 if err != nil { 3306 var snapshot bytes.Buffer 3307 io.Copy(&snapshot, ringBuffer) 3308 return out, metadata, &smithy.DeserializationError{ 3309 Err: fmt.Errorf("failed to decode response body, %w", err), 3310 Snapshot: snapshot.Bytes(), 3311 } 3312 } 3313 3314 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3315 err = awsRestxml_deserializeOpDocumentGetBucketLifecycleConfigurationOutput(&output, decoder) 3316 if err != nil { 3317 var snapshot bytes.Buffer 3318 io.Copy(&snapshot, ringBuffer) 3319 return out, metadata, &smithy.DeserializationError{ 3320 Err: fmt.Errorf("failed to decode response body, %w", err), 3321 Snapshot: snapshot.Bytes(), 3322 } 3323 } 3324 3325 return out, metadata, err 3326} 3327 3328func awsRestxml_deserializeOpErrorGetBucketLifecycleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3329 var errorBuffer bytes.Buffer 3330 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3331 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3332 } 3333 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3334 3335 errorCode := "UnknownError" 3336 errorMessage := errorCode 3337 3338 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3339 UseStatusCode: true, StatusCode: response.StatusCode, 3340 }) 3341 if err != nil { 3342 return err 3343 } 3344 if hostID := errorComponents.HostID; len(hostID) != 0 { 3345 s3shared.SetHostIDMetadata(metadata, hostID) 3346 } 3347 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3348 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3349 } 3350 if len(errorComponents.Code) != 0 { 3351 errorCode = errorComponents.Code 3352 } 3353 if len(errorComponents.Message) != 0 { 3354 errorMessage = errorComponents.Message 3355 } 3356 errorBody.Seek(0, io.SeekStart) 3357 switch { 3358 default: 3359 genericError := &smithy.GenericAPIError{ 3360 Code: errorCode, 3361 Message: errorMessage, 3362 } 3363 return genericError 3364 3365 } 3366} 3367 3368func awsRestxml_deserializeOpDocumentGetBucketLifecycleConfigurationOutput(v **GetBucketLifecycleConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3369 if v == nil { 3370 return fmt.Errorf("unexpected nil of type %T", v) 3371 } 3372 var sv *GetBucketLifecycleConfigurationOutput 3373 if *v == nil { 3374 sv = &GetBucketLifecycleConfigurationOutput{} 3375 } else { 3376 sv = *v 3377 } 3378 3379 for { 3380 t, done, err := decoder.Token() 3381 if err != nil { 3382 return err 3383 } 3384 if done { 3385 break 3386 } 3387 originalDecoder := decoder 3388 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3389 switch { 3390 case strings.EqualFold("Rule", t.Name.Local): 3391 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3392 if err := awsRestxml_deserializeDocumentLifecycleRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 3393 return err 3394 } 3395 3396 default: 3397 // Do nothing and ignore the unexpected tag element 3398 err = decoder.Decoder.Skip() 3399 if err != nil { 3400 return err 3401 } 3402 3403 } 3404 decoder = originalDecoder 3405 } 3406 *v = sv 3407 return nil 3408} 3409 3410type awsRestxml_deserializeOpGetBucketLocation struct { 3411} 3412 3413func (*awsRestxml_deserializeOpGetBucketLocation) ID() string { 3414 return "OperationDeserializer" 3415} 3416 3417func (m *awsRestxml_deserializeOpGetBucketLocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3418 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3419) { 3420 out, metadata, err = next.HandleDeserialize(ctx, in) 3421 if err != nil { 3422 return out, metadata, err 3423 } 3424 3425 response, ok := out.RawResponse.(*smithyhttp.Response) 3426 if !ok { 3427 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3428 } 3429 3430 if response.StatusCode < 200 || response.StatusCode >= 300 { 3431 return out, metadata, awsRestxml_deserializeOpErrorGetBucketLocation(response, &metadata) 3432 } 3433 output := &GetBucketLocationOutput{} 3434 out.Result = output 3435 3436 var buff [1024]byte 3437 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3438 body := io.TeeReader(response.Body, ringBuffer) 3439 rootDecoder := xml.NewDecoder(body) 3440 t, err := smithyxml.FetchRootElement(rootDecoder) 3441 if err == io.EOF { 3442 return out, metadata, nil 3443 } 3444 if err != nil { 3445 var snapshot bytes.Buffer 3446 io.Copy(&snapshot, ringBuffer) 3447 return out, metadata, &smithy.DeserializationError{ 3448 Err: fmt.Errorf("failed to decode response body, %w", err), 3449 Snapshot: snapshot.Bytes(), 3450 } 3451 } 3452 3453 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3454 err = awsRestxml_deserializeOpDocumentGetBucketLocationOutput(&output, decoder) 3455 if err != nil { 3456 var snapshot bytes.Buffer 3457 io.Copy(&snapshot, ringBuffer) 3458 return out, metadata, &smithy.DeserializationError{ 3459 Err: fmt.Errorf("failed to decode response body, %w", err), 3460 Snapshot: snapshot.Bytes(), 3461 } 3462 } 3463 3464 return out, metadata, err 3465} 3466 3467func awsRestxml_deserializeOpErrorGetBucketLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3468 var errorBuffer bytes.Buffer 3469 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3470 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3471 } 3472 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3473 3474 errorCode := "UnknownError" 3475 errorMessage := errorCode 3476 3477 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3478 UseStatusCode: true, StatusCode: response.StatusCode, 3479 }) 3480 if err != nil { 3481 return err 3482 } 3483 if hostID := errorComponents.HostID; len(hostID) != 0 { 3484 s3shared.SetHostIDMetadata(metadata, hostID) 3485 } 3486 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3487 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3488 } 3489 if len(errorComponents.Code) != 0 { 3490 errorCode = errorComponents.Code 3491 } 3492 if len(errorComponents.Message) != 0 { 3493 errorMessage = errorComponents.Message 3494 } 3495 errorBody.Seek(0, io.SeekStart) 3496 switch { 3497 default: 3498 genericError := &smithy.GenericAPIError{ 3499 Code: errorCode, 3500 Message: errorMessage, 3501 } 3502 return genericError 3503 3504 } 3505} 3506 3507func awsRestxml_deserializeOpDocumentGetBucketLocationOutput(v **GetBucketLocationOutput, decoder smithyxml.NodeDecoder) error { 3508 if v == nil { 3509 return fmt.Errorf("unexpected nil of type %T", v) 3510 } 3511 var sv *GetBucketLocationOutput 3512 if *v == nil { 3513 sv = &GetBucketLocationOutput{} 3514 } else { 3515 sv = *v 3516 } 3517 3518 for { 3519 t, done, err := decoder.Token() 3520 if err != nil { 3521 return err 3522 } 3523 if done { 3524 break 3525 } 3526 originalDecoder := decoder 3527 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3528 switch { 3529 case strings.EqualFold("LocationConstraint", t.Name.Local): 3530 val, err := decoder.Value() 3531 if err != nil { 3532 return err 3533 } 3534 if val == nil { 3535 break 3536 } 3537 { 3538 xtv := string(val) 3539 sv.LocationConstraint = types.BucketLocationConstraint(xtv) 3540 } 3541 3542 default: 3543 // Do nothing and ignore the unexpected tag element 3544 err = decoder.Decoder.Skip() 3545 if err != nil { 3546 return err 3547 } 3548 3549 } 3550 decoder = originalDecoder 3551 } 3552 *v = sv 3553 return nil 3554} 3555 3556type awsRestxml_deserializeOpGetBucketLogging struct { 3557} 3558 3559func (*awsRestxml_deserializeOpGetBucketLogging) ID() string { 3560 return "OperationDeserializer" 3561} 3562 3563func (m *awsRestxml_deserializeOpGetBucketLogging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3564 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3565) { 3566 out, metadata, err = next.HandleDeserialize(ctx, in) 3567 if err != nil { 3568 return out, metadata, err 3569 } 3570 3571 response, ok := out.RawResponse.(*smithyhttp.Response) 3572 if !ok { 3573 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3574 } 3575 3576 if response.StatusCode < 200 || response.StatusCode >= 300 { 3577 return out, metadata, awsRestxml_deserializeOpErrorGetBucketLogging(response, &metadata) 3578 } 3579 output := &GetBucketLoggingOutput{} 3580 out.Result = output 3581 3582 var buff [1024]byte 3583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3584 body := io.TeeReader(response.Body, ringBuffer) 3585 rootDecoder := xml.NewDecoder(body) 3586 t, err := smithyxml.FetchRootElement(rootDecoder) 3587 if err == io.EOF { 3588 return out, metadata, nil 3589 } 3590 if err != nil { 3591 var snapshot bytes.Buffer 3592 io.Copy(&snapshot, ringBuffer) 3593 return out, metadata, &smithy.DeserializationError{ 3594 Err: fmt.Errorf("failed to decode response body, %w", err), 3595 Snapshot: snapshot.Bytes(), 3596 } 3597 } 3598 3599 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3600 err = awsRestxml_deserializeOpDocumentGetBucketLoggingOutput(&output, decoder) 3601 if err != nil { 3602 var snapshot bytes.Buffer 3603 io.Copy(&snapshot, ringBuffer) 3604 return out, metadata, &smithy.DeserializationError{ 3605 Err: fmt.Errorf("failed to decode response body, %w", err), 3606 Snapshot: snapshot.Bytes(), 3607 } 3608 } 3609 3610 return out, metadata, err 3611} 3612 3613func awsRestxml_deserializeOpErrorGetBucketLogging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3614 var errorBuffer bytes.Buffer 3615 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3616 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3617 } 3618 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3619 3620 errorCode := "UnknownError" 3621 errorMessage := errorCode 3622 3623 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3624 UseStatusCode: true, StatusCode: response.StatusCode, 3625 }) 3626 if err != nil { 3627 return err 3628 } 3629 if hostID := errorComponents.HostID; len(hostID) != 0 { 3630 s3shared.SetHostIDMetadata(metadata, hostID) 3631 } 3632 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3633 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3634 } 3635 if len(errorComponents.Code) != 0 { 3636 errorCode = errorComponents.Code 3637 } 3638 if len(errorComponents.Message) != 0 { 3639 errorMessage = errorComponents.Message 3640 } 3641 errorBody.Seek(0, io.SeekStart) 3642 switch { 3643 default: 3644 genericError := &smithy.GenericAPIError{ 3645 Code: errorCode, 3646 Message: errorMessage, 3647 } 3648 return genericError 3649 3650 } 3651} 3652 3653func awsRestxml_deserializeOpDocumentGetBucketLoggingOutput(v **GetBucketLoggingOutput, decoder smithyxml.NodeDecoder) error { 3654 if v == nil { 3655 return fmt.Errorf("unexpected nil of type %T", v) 3656 } 3657 var sv *GetBucketLoggingOutput 3658 if *v == nil { 3659 sv = &GetBucketLoggingOutput{} 3660 } else { 3661 sv = *v 3662 } 3663 3664 for { 3665 t, done, err := decoder.Token() 3666 if err != nil { 3667 return err 3668 } 3669 if done { 3670 break 3671 } 3672 originalDecoder := decoder 3673 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3674 switch { 3675 case strings.EqualFold("LoggingEnabled", t.Name.Local): 3676 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3677 if err := awsRestxml_deserializeDocumentLoggingEnabled(&sv.LoggingEnabled, nodeDecoder); err != nil { 3678 return err 3679 } 3680 3681 default: 3682 // Do nothing and ignore the unexpected tag element 3683 err = decoder.Decoder.Skip() 3684 if err != nil { 3685 return err 3686 } 3687 3688 } 3689 decoder = originalDecoder 3690 } 3691 *v = sv 3692 return nil 3693} 3694 3695type awsRestxml_deserializeOpGetBucketMetricsConfiguration struct { 3696} 3697 3698func (*awsRestxml_deserializeOpGetBucketMetricsConfiguration) ID() string { 3699 return "OperationDeserializer" 3700} 3701 3702func (m *awsRestxml_deserializeOpGetBucketMetricsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3703 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3704) { 3705 out, metadata, err = next.HandleDeserialize(ctx, in) 3706 if err != nil { 3707 return out, metadata, err 3708 } 3709 3710 response, ok := out.RawResponse.(*smithyhttp.Response) 3711 if !ok { 3712 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3713 } 3714 3715 if response.StatusCode < 200 || response.StatusCode >= 300 { 3716 return out, metadata, awsRestxml_deserializeOpErrorGetBucketMetricsConfiguration(response, &metadata) 3717 } 3718 output := &GetBucketMetricsConfigurationOutput{} 3719 out.Result = output 3720 3721 var buff [1024]byte 3722 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3723 body := io.TeeReader(response.Body, ringBuffer) 3724 rootDecoder := xml.NewDecoder(body) 3725 t, err := smithyxml.FetchRootElement(rootDecoder) 3726 if err == io.EOF { 3727 return out, metadata, nil 3728 } 3729 if err != nil { 3730 var snapshot bytes.Buffer 3731 io.Copy(&snapshot, ringBuffer) 3732 return out, metadata, &smithy.DeserializationError{ 3733 Err: fmt.Errorf("failed to decode response body, %w", err), 3734 Snapshot: snapshot.Bytes(), 3735 } 3736 } 3737 3738 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3739 err = awsRestxml_deserializeDocumentMetricsConfiguration(&output.MetricsConfiguration, decoder) 3740 if err != nil { 3741 var snapshot bytes.Buffer 3742 io.Copy(&snapshot, ringBuffer) 3743 return out, metadata, &smithy.DeserializationError{ 3744 Err: fmt.Errorf("failed to decode response body, %w", err), 3745 Snapshot: snapshot.Bytes(), 3746 } 3747 } 3748 3749 return out, metadata, err 3750} 3751 3752func awsRestxml_deserializeOpErrorGetBucketMetricsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3753 var errorBuffer bytes.Buffer 3754 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3755 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3756 } 3757 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3758 3759 errorCode := "UnknownError" 3760 errorMessage := errorCode 3761 3762 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3763 UseStatusCode: true, StatusCode: response.StatusCode, 3764 }) 3765 if err != nil { 3766 return err 3767 } 3768 if hostID := errorComponents.HostID; len(hostID) != 0 { 3769 s3shared.SetHostIDMetadata(metadata, hostID) 3770 } 3771 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3772 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3773 } 3774 if len(errorComponents.Code) != 0 { 3775 errorCode = errorComponents.Code 3776 } 3777 if len(errorComponents.Message) != 0 { 3778 errorMessage = errorComponents.Message 3779 } 3780 errorBody.Seek(0, io.SeekStart) 3781 switch { 3782 default: 3783 genericError := &smithy.GenericAPIError{ 3784 Code: errorCode, 3785 Message: errorMessage, 3786 } 3787 return genericError 3788 3789 } 3790} 3791 3792func awsRestxml_deserializeOpDocumentGetBucketMetricsConfigurationOutput(v **GetBucketMetricsConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3793 if v == nil { 3794 return fmt.Errorf("unexpected nil of type %T", v) 3795 } 3796 var sv *GetBucketMetricsConfigurationOutput 3797 if *v == nil { 3798 sv = &GetBucketMetricsConfigurationOutput{} 3799 } else { 3800 sv = *v 3801 } 3802 3803 for { 3804 t, done, err := decoder.Token() 3805 if err != nil { 3806 return err 3807 } 3808 if done { 3809 break 3810 } 3811 originalDecoder := decoder 3812 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3813 switch { 3814 case strings.EqualFold("MetricsConfiguration", t.Name.Local): 3815 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3816 if err := awsRestxml_deserializeDocumentMetricsConfiguration(&sv.MetricsConfiguration, nodeDecoder); err != nil { 3817 return err 3818 } 3819 3820 default: 3821 // Do nothing and ignore the unexpected tag element 3822 err = decoder.Decoder.Skip() 3823 if err != nil { 3824 return err 3825 } 3826 3827 } 3828 decoder = originalDecoder 3829 } 3830 *v = sv 3831 return nil 3832} 3833 3834type awsRestxml_deserializeOpGetBucketNotificationConfiguration struct { 3835} 3836 3837func (*awsRestxml_deserializeOpGetBucketNotificationConfiguration) ID() string { 3838 return "OperationDeserializer" 3839} 3840 3841func (m *awsRestxml_deserializeOpGetBucketNotificationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3842 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3843) { 3844 out, metadata, err = next.HandleDeserialize(ctx, in) 3845 if err != nil { 3846 return out, metadata, err 3847 } 3848 3849 response, ok := out.RawResponse.(*smithyhttp.Response) 3850 if !ok { 3851 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3852 } 3853 3854 if response.StatusCode < 200 || response.StatusCode >= 300 { 3855 return out, metadata, awsRestxml_deserializeOpErrorGetBucketNotificationConfiguration(response, &metadata) 3856 } 3857 output := &GetBucketNotificationConfigurationOutput{} 3858 out.Result = output 3859 3860 var buff [1024]byte 3861 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3862 body := io.TeeReader(response.Body, ringBuffer) 3863 rootDecoder := xml.NewDecoder(body) 3864 t, err := smithyxml.FetchRootElement(rootDecoder) 3865 if err == io.EOF { 3866 return out, metadata, nil 3867 } 3868 if err != nil { 3869 var snapshot bytes.Buffer 3870 io.Copy(&snapshot, ringBuffer) 3871 return out, metadata, &smithy.DeserializationError{ 3872 Err: fmt.Errorf("failed to decode response body, %w", err), 3873 Snapshot: snapshot.Bytes(), 3874 } 3875 } 3876 3877 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 3878 err = awsRestxml_deserializeOpDocumentGetBucketNotificationConfigurationOutput(&output, decoder) 3879 if err != nil { 3880 var snapshot bytes.Buffer 3881 io.Copy(&snapshot, ringBuffer) 3882 return out, metadata, &smithy.DeserializationError{ 3883 Err: fmt.Errorf("failed to decode response body, %w", err), 3884 Snapshot: snapshot.Bytes(), 3885 } 3886 } 3887 3888 return out, metadata, err 3889} 3890 3891func awsRestxml_deserializeOpErrorGetBucketNotificationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3892 var errorBuffer bytes.Buffer 3893 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3894 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3895 } 3896 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3897 3898 errorCode := "UnknownError" 3899 errorMessage := errorCode 3900 3901 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 3902 UseStatusCode: true, StatusCode: response.StatusCode, 3903 }) 3904 if err != nil { 3905 return err 3906 } 3907 if hostID := errorComponents.HostID; len(hostID) != 0 { 3908 s3shared.SetHostIDMetadata(metadata, hostID) 3909 } 3910 if reqID := errorComponents.RequestID; len(reqID) != 0 { 3911 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 3912 } 3913 if len(errorComponents.Code) != 0 { 3914 errorCode = errorComponents.Code 3915 } 3916 if len(errorComponents.Message) != 0 { 3917 errorMessage = errorComponents.Message 3918 } 3919 errorBody.Seek(0, io.SeekStart) 3920 switch { 3921 default: 3922 genericError := &smithy.GenericAPIError{ 3923 Code: errorCode, 3924 Message: errorMessage, 3925 } 3926 return genericError 3927 3928 } 3929} 3930 3931func awsRestxml_deserializeOpDocumentGetBucketNotificationConfigurationOutput(v **GetBucketNotificationConfigurationOutput, decoder smithyxml.NodeDecoder) error { 3932 if v == nil { 3933 return fmt.Errorf("unexpected nil of type %T", v) 3934 } 3935 var sv *GetBucketNotificationConfigurationOutput 3936 if *v == nil { 3937 sv = &GetBucketNotificationConfigurationOutput{} 3938 } else { 3939 sv = *v 3940 } 3941 3942 for { 3943 t, done, err := decoder.Token() 3944 if err != nil { 3945 return err 3946 } 3947 if done { 3948 break 3949 } 3950 originalDecoder := decoder 3951 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 3952 switch { 3953 case strings.EqualFold("CloudFunctionConfiguration", t.Name.Local): 3954 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3955 if err := awsRestxml_deserializeDocumentLambdaFunctionConfigurationListUnwrapped(&sv.LambdaFunctionConfigurations, nodeDecoder); err != nil { 3956 return err 3957 } 3958 3959 case strings.EqualFold("QueueConfiguration", t.Name.Local): 3960 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3961 if err := awsRestxml_deserializeDocumentQueueConfigurationListUnwrapped(&sv.QueueConfigurations, nodeDecoder); err != nil { 3962 return err 3963 } 3964 3965 case strings.EqualFold("TopicConfiguration", t.Name.Local): 3966 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 3967 if err := awsRestxml_deserializeDocumentTopicConfigurationListUnwrapped(&sv.TopicConfigurations, nodeDecoder); err != nil { 3968 return err 3969 } 3970 3971 default: 3972 // Do nothing and ignore the unexpected tag element 3973 err = decoder.Decoder.Skip() 3974 if err != nil { 3975 return err 3976 } 3977 3978 } 3979 decoder = originalDecoder 3980 } 3981 *v = sv 3982 return nil 3983} 3984 3985type awsRestxml_deserializeOpGetBucketOwnershipControls struct { 3986} 3987 3988func (*awsRestxml_deserializeOpGetBucketOwnershipControls) ID() string { 3989 return "OperationDeserializer" 3990} 3991 3992func (m *awsRestxml_deserializeOpGetBucketOwnershipControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3993 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3994) { 3995 out, metadata, err = next.HandleDeserialize(ctx, in) 3996 if err != nil { 3997 return out, metadata, err 3998 } 3999 4000 response, ok := out.RawResponse.(*smithyhttp.Response) 4001 if !ok { 4002 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4003 } 4004 4005 if response.StatusCode < 200 || response.StatusCode >= 300 { 4006 return out, metadata, awsRestxml_deserializeOpErrorGetBucketOwnershipControls(response, &metadata) 4007 } 4008 output := &GetBucketOwnershipControlsOutput{} 4009 out.Result = output 4010 4011 var buff [1024]byte 4012 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4013 body := io.TeeReader(response.Body, ringBuffer) 4014 rootDecoder := xml.NewDecoder(body) 4015 t, err := smithyxml.FetchRootElement(rootDecoder) 4016 if err == io.EOF { 4017 return out, metadata, nil 4018 } 4019 if err != nil { 4020 var snapshot bytes.Buffer 4021 io.Copy(&snapshot, ringBuffer) 4022 return out, metadata, &smithy.DeserializationError{ 4023 Err: fmt.Errorf("failed to decode response body, %w", err), 4024 Snapshot: snapshot.Bytes(), 4025 } 4026 } 4027 4028 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4029 err = awsRestxml_deserializeDocumentOwnershipControls(&output.OwnershipControls, decoder) 4030 if err != nil { 4031 var snapshot bytes.Buffer 4032 io.Copy(&snapshot, ringBuffer) 4033 return out, metadata, &smithy.DeserializationError{ 4034 Err: fmt.Errorf("failed to decode response body, %w", err), 4035 Snapshot: snapshot.Bytes(), 4036 } 4037 } 4038 4039 return out, metadata, err 4040} 4041 4042func awsRestxml_deserializeOpErrorGetBucketOwnershipControls(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4043 var errorBuffer bytes.Buffer 4044 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4045 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4046 } 4047 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4048 4049 errorCode := "UnknownError" 4050 errorMessage := errorCode 4051 4052 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4053 UseStatusCode: true, StatusCode: response.StatusCode, 4054 }) 4055 if err != nil { 4056 return err 4057 } 4058 if hostID := errorComponents.HostID; len(hostID) != 0 { 4059 s3shared.SetHostIDMetadata(metadata, hostID) 4060 } 4061 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4062 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4063 } 4064 if len(errorComponents.Code) != 0 { 4065 errorCode = errorComponents.Code 4066 } 4067 if len(errorComponents.Message) != 0 { 4068 errorMessage = errorComponents.Message 4069 } 4070 errorBody.Seek(0, io.SeekStart) 4071 switch { 4072 default: 4073 genericError := &smithy.GenericAPIError{ 4074 Code: errorCode, 4075 Message: errorMessage, 4076 } 4077 return genericError 4078 4079 } 4080} 4081 4082func awsRestxml_deserializeOpDocumentGetBucketOwnershipControlsOutput(v **GetBucketOwnershipControlsOutput, decoder smithyxml.NodeDecoder) error { 4083 if v == nil { 4084 return fmt.Errorf("unexpected nil of type %T", v) 4085 } 4086 var sv *GetBucketOwnershipControlsOutput 4087 if *v == nil { 4088 sv = &GetBucketOwnershipControlsOutput{} 4089 } else { 4090 sv = *v 4091 } 4092 4093 for { 4094 t, done, err := decoder.Token() 4095 if err != nil { 4096 return err 4097 } 4098 if done { 4099 break 4100 } 4101 originalDecoder := decoder 4102 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4103 switch { 4104 case strings.EqualFold("OwnershipControls", t.Name.Local): 4105 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4106 if err := awsRestxml_deserializeDocumentOwnershipControls(&sv.OwnershipControls, nodeDecoder); err != nil { 4107 return err 4108 } 4109 4110 default: 4111 // Do nothing and ignore the unexpected tag element 4112 err = decoder.Decoder.Skip() 4113 if err != nil { 4114 return err 4115 } 4116 4117 } 4118 decoder = originalDecoder 4119 } 4120 *v = sv 4121 return nil 4122} 4123 4124type awsRestxml_deserializeOpGetBucketPolicy struct { 4125} 4126 4127func (*awsRestxml_deserializeOpGetBucketPolicy) ID() string { 4128 return "OperationDeserializer" 4129} 4130 4131func (m *awsRestxml_deserializeOpGetBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4132 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4133) { 4134 out, metadata, err = next.HandleDeserialize(ctx, in) 4135 if err != nil { 4136 return out, metadata, err 4137 } 4138 4139 response, ok := out.RawResponse.(*smithyhttp.Response) 4140 if !ok { 4141 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4142 } 4143 4144 if response.StatusCode < 200 || response.StatusCode >= 300 { 4145 return out, metadata, awsRestxml_deserializeOpErrorGetBucketPolicy(response, &metadata) 4146 } 4147 output := &GetBucketPolicyOutput{} 4148 out.Result = output 4149 4150 var buff [1024]byte 4151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4152 body := io.TeeReader(response.Body, ringBuffer) 4153 rootDecoder := xml.NewDecoder(body) 4154 t, err := smithyxml.FetchRootElement(rootDecoder) 4155 if err == io.EOF { 4156 return out, metadata, nil 4157 } 4158 if err != nil { 4159 var snapshot bytes.Buffer 4160 io.Copy(&snapshot, ringBuffer) 4161 return out, metadata, &smithy.DeserializationError{ 4162 Err: fmt.Errorf("failed to decode response body, %w", err), 4163 Snapshot: snapshot.Bytes(), 4164 } 4165 } 4166 4167 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4168 err = awsRestxml_deserializeOpDocumentGetBucketPolicyOutput(&output, decoder) 4169 if err != nil { 4170 var snapshot bytes.Buffer 4171 io.Copy(&snapshot, ringBuffer) 4172 return out, metadata, &smithy.DeserializationError{ 4173 Err: fmt.Errorf("failed to decode response body, %w", err), 4174 Snapshot: snapshot.Bytes(), 4175 } 4176 } 4177 4178 return out, metadata, err 4179} 4180 4181func awsRestxml_deserializeOpErrorGetBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4182 var errorBuffer bytes.Buffer 4183 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4184 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4185 } 4186 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4187 4188 errorCode := "UnknownError" 4189 errorMessage := errorCode 4190 4191 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4192 UseStatusCode: true, StatusCode: response.StatusCode, 4193 }) 4194 if err != nil { 4195 return err 4196 } 4197 if hostID := errorComponents.HostID; len(hostID) != 0 { 4198 s3shared.SetHostIDMetadata(metadata, hostID) 4199 } 4200 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4201 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4202 } 4203 if len(errorComponents.Code) != 0 { 4204 errorCode = errorComponents.Code 4205 } 4206 if len(errorComponents.Message) != 0 { 4207 errorMessage = errorComponents.Message 4208 } 4209 errorBody.Seek(0, io.SeekStart) 4210 switch { 4211 default: 4212 genericError := &smithy.GenericAPIError{ 4213 Code: errorCode, 4214 Message: errorMessage, 4215 } 4216 return genericError 4217 4218 } 4219} 4220 4221func awsRestxml_deserializeOpDocumentGetBucketPolicyOutput(v **GetBucketPolicyOutput, decoder smithyxml.NodeDecoder) error { 4222 if v == nil { 4223 return fmt.Errorf("unexpected nil of type %T", v) 4224 } 4225 var sv *GetBucketPolicyOutput 4226 if *v == nil { 4227 sv = &GetBucketPolicyOutput{} 4228 } else { 4229 sv = *v 4230 } 4231 4232 for { 4233 t, done, err := decoder.Token() 4234 if err != nil { 4235 return err 4236 } 4237 if done { 4238 break 4239 } 4240 originalDecoder := decoder 4241 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4242 switch { 4243 case strings.EqualFold("Policy", t.Name.Local): 4244 val, err := decoder.Value() 4245 if err != nil { 4246 return err 4247 } 4248 if val == nil { 4249 break 4250 } 4251 { 4252 xtv := string(val) 4253 sv.Policy = ptr.String(xtv) 4254 } 4255 4256 default: 4257 // Do nothing and ignore the unexpected tag element 4258 err = decoder.Decoder.Skip() 4259 if err != nil { 4260 return err 4261 } 4262 4263 } 4264 decoder = originalDecoder 4265 } 4266 *v = sv 4267 return nil 4268} 4269 4270type awsRestxml_deserializeOpGetBucketPolicyStatus struct { 4271} 4272 4273func (*awsRestxml_deserializeOpGetBucketPolicyStatus) ID() string { 4274 return "OperationDeserializer" 4275} 4276 4277func (m *awsRestxml_deserializeOpGetBucketPolicyStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4278 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4279) { 4280 out, metadata, err = next.HandleDeserialize(ctx, in) 4281 if err != nil { 4282 return out, metadata, err 4283 } 4284 4285 response, ok := out.RawResponse.(*smithyhttp.Response) 4286 if !ok { 4287 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4288 } 4289 4290 if response.StatusCode < 200 || response.StatusCode >= 300 { 4291 return out, metadata, awsRestxml_deserializeOpErrorGetBucketPolicyStatus(response, &metadata) 4292 } 4293 output := &GetBucketPolicyStatusOutput{} 4294 out.Result = output 4295 4296 var buff [1024]byte 4297 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4298 body := io.TeeReader(response.Body, ringBuffer) 4299 rootDecoder := xml.NewDecoder(body) 4300 t, err := smithyxml.FetchRootElement(rootDecoder) 4301 if err == io.EOF { 4302 return out, metadata, nil 4303 } 4304 if err != nil { 4305 var snapshot bytes.Buffer 4306 io.Copy(&snapshot, ringBuffer) 4307 return out, metadata, &smithy.DeserializationError{ 4308 Err: fmt.Errorf("failed to decode response body, %w", err), 4309 Snapshot: snapshot.Bytes(), 4310 } 4311 } 4312 4313 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4314 err = awsRestxml_deserializeDocumentPolicyStatus(&output.PolicyStatus, decoder) 4315 if err != nil { 4316 var snapshot bytes.Buffer 4317 io.Copy(&snapshot, ringBuffer) 4318 return out, metadata, &smithy.DeserializationError{ 4319 Err: fmt.Errorf("failed to decode response body, %w", err), 4320 Snapshot: snapshot.Bytes(), 4321 } 4322 } 4323 4324 return out, metadata, err 4325} 4326 4327func awsRestxml_deserializeOpErrorGetBucketPolicyStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4328 var errorBuffer bytes.Buffer 4329 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4330 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4331 } 4332 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4333 4334 errorCode := "UnknownError" 4335 errorMessage := errorCode 4336 4337 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4338 UseStatusCode: true, StatusCode: response.StatusCode, 4339 }) 4340 if err != nil { 4341 return err 4342 } 4343 if hostID := errorComponents.HostID; len(hostID) != 0 { 4344 s3shared.SetHostIDMetadata(metadata, hostID) 4345 } 4346 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4347 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4348 } 4349 if len(errorComponents.Code) != 0 { 4350 errorCode = errorComponents.Code 4351 } 4352 if len(errorComponents.Message) != 0 { 4353 errorMessage = errorComponents.Message 4354 } 4355 errorBody.Seek(0, io.SeekStart) 4356 switch { 4357 default: 4358 genericError := &smithy.GenericAPIError{ 4359 Code: errorCode, 4360 Message: errorMessage, 4361 } 4362 return genericError 4363 4364 } 4365} 4366 4367func awsRestxml_deserializeOpDocumentGetBucketPolicyStatusOutput(v **GetBucketPolicyStatusOutput, decoder smithyxml.NodeDecoder) error { 4368 if v == nil { 4369 return fmt.Errorf("unexpected nil of type %T", v) 4370 } 4371 var sv *GetBucketPolicyStatusOutput 4372 if *v == nil { 4373 sv = &GetBucketPolicyStatusOutput{} 4374 } else { 4375 sv = *v 4376 } 4377 4378 for { 4379 t, done, err := decoder.Token() 4380 if err != nil { 4381 return err 4382 } 4383 if done { 4384 break 4385 } 4386 originalDecoder := decoder 4387 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4388 switch { 4389 case strings.EqualFold("PolicyStatus", t.Name.Local): 4390 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4391 if err := awsRestxml_deserializeDocumentPolicyStatus(&sv.PolicyStatus, nodeDecoder); err != nil { 4392 return err 4393 } 4394 4395 default: 4396 // Do nothing and ignore the unexpected tag element 4397 err = decoder.Decoder.Skip() 4398 if err != nil { 4399 return err 4400 } 4401 4402 } 4403 decoder = originalDecoder 4404 } 4405 *v = sv 4406 return nil 4407} 4408 4409type awsRestxml_deserializeOpGetBucketReplication struct { 4410} 4411 4412func (*awsRestxml_deserializeOpGetBucketReplication) ID() string { 4413 return "OperationDeserializer" 4414} 4415 4416func (m *awsRestxml_deserializeOpGetBucketReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4417 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4418) { 4419 out, metadata, err = next.HandleDeserialize(ctx, in) 4420 if err != nil { 4421 return out, metadata, err 4422 } 4423 4424 response, ok := out.RawResponse.(*smithyhttp.Response) 4425 if !ok { 4426 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4427 } 4428 4429 if response.StatusCode < 200 || response.StatusCode >= 300 { 4430 return out, metadata, awsRestxml_deserializeOpErrorGetBucketReplication(response, &metadata) 4431 } 4432 output := &GetBucketReplicationOutput{} 4433 out.Result = output 4434 4435 var buff [1024]byte 4436 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4437 body := io.TeeReader(response.Body, ringBuffer) 4438 rootDecoder := xml.NewDecoder(body) 4439 t, err := smithyxml.FetchRootElement(rootDecoder) 4440 if err == io.EOF { 4441 return out, metadata, nil 4442 } 4443 if err != nil { 4444 var snapshot bytes.Buffer 4445 io.Copy(&snapshot, ringBuffer) 4446 return out, metadata, &smithy.DeserializationError{ 4447 Err: fmt.Errorf("failed to decode response body, %w", err), 4448 Snapshot: snapshot.Bytes(), 4449 } 4450 } 4451 4452 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4453 err = awsRestxml_deserializeDocumentReplicationConfiguration(&output.ReplicationConfiguration, decoder) 4454 if err != nil { 4455 var snapshot bytes.Buffer 4456 io.Copy(&snapshot, ringBuffer) 4457 return out, metadata, &smithy.DeserializationError{ 4458 Err: fmt.Errorf("failed to decode response body, %w", err), 4459 Snapshot: snapshot.Bytes(), 4460 } 4461 } 4462 4463 return out, metadata, err 4464} 4465 4466func awsRestxml_deserializeOpErrorGetBucketReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4467 var errorBuffer bytes.Buffer 4468 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4469 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4470 } 4471 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4472 4473 errorCode := "UnknownError" 4474 errorMessage := errorCode 4475 4476 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4477 UseStatusCode: true, StatusCode: response.StatusCode, 4478 }) 4479 if err != nil { 4480 return err 4481 } 4482 if hostID := errorComponents.HostID; len(hostID) != 0 { 4483 s3shared.SetHostIDMetadata(metadata, hostID) 4484 } 4485 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4486 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4487 } 4488 if len(errorComponents.Code) != 0 { 4489 errorCode = errorComponents.Code 4490 } 4491 if len(errorComponents.Message) != 0 { 4492 errorMessage = errorComponents.Message 4493 } 4494 errorBody.Seek(0, io.SeekStart) 4495 switch { 4496 default: 4497 genericError := &smithy.GenericAPIError{ 4498 Code: errorCode, 4499 Message: errorMessage, 4500 } 4501 return genericError 4502 4503 } 4504} 4505 4506func awsRestxml_deserializeOpDocumentGetBucketReplicationOutput(v **GetBucketReplicationOutput, decoder smithyxml.NodeDecoder) error { 4507 if v == nil { 4508 return fmt.Errorf("unexpected nil of type %T", v) 4509 } 4510 var sv *GetBucketReplicationOutput 4511 if *v == nil { 4512 sv = &GetBucketReplicationOutput{} 4513 } else { 4514 sv = *v 4515 } 4516 4517 for { 4518 t, done, err := decoder.Token() 4519 if err != nil { 4520 return err 4521 } 4522 if done { 4523 break 4524 } 4525 originalDecoder := decoder 4526 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4527 switch { 4528 case strings.EqualFold("ReplicationConfiguration", t.Name.Local): 4529 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4530 if err := awsRestxml_deserializeDocumentReplicationConfiguration(&sv.ReplicationConfiguration, nodeDecoder); err != nil { 4531 return err 4532 } 4533 4534 default: 4535 // Do nothing and ignore the unexpected tag element 4536 err = decoder.Decoder.Skip() 4537 if err != nil { 4538 return err 4539 } 4540 4541 } 4542 decoder = originalDecoder 4543 } 4544 *v = sv 4545 return nil 4546} 4547 4548type awsRestxml_deserializeOpGetBucketRequestPayment struct { 4549} 4550 4551func (*awsRestxml_deserializeOpGetBucketRequestPayment) ID() string { 4552 return "OperationDeserializer" 4553} 4554 4555func (m *awsRestxml_deserializeOpGetBucketRequestPayment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4556 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4557) { 4558 out, metadata, err = next.HandleDeserialize(ctx, in) 4559 if err != nil { 4560 return out, metadata, err 4561 } 4562 4563 response, ok := out.RawResponse.(*smithyhttp.Response) 4564 if !ok { 4565 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4566 } 4567 4568 if response.StatusCode < 200 || response.StatusCode >= 300 { 4569 return out, metadata, awsRestxml_deserializeOpErrorGetBucketRequestPayment(response, &metadata) 4570 } 4571 output := &GetBucketRequestPaymentOutput{} 4572 out.Result = output 4573 4574 var buff [1024]byte 4575 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4576 body := io.TeeReader(response.Body, ringBuffer) 4577 rootDecoder := xml.NewDecoder(body) 4578 t, err := smithyxml.FetchRootElement(rootDecoder) 4579 if err == io.EOF { 4580 return out, metadata, nil 4581 } 4582 if err != nil { 4583 var snapshot bytes.Buffer 4584 io.Copy(&snapshot, ringBuffer) 4585 return out, metadata, &smithy.DeserializationError{ 4586 Err: fmt.Errorf("failed to decode response body, %w", err), 4587 Snapshot: snapshot.Bytes(), 4588 } 4589 } 4590 4591 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4592 err = awsRestxml_deserializeOpDocumentGetBucketRequestPaymentOutput(&output, decoder) 4593 if err != nil { 4594 var snapshot bytes.Buffer 4595 io.Copy(&snapshot, ringBuffer) 4596 return out, metadata, &smithy.DeserializationError{ 4597 Err: fmt.Errorf("failed to decode response body, %w", err), 4598 Snapshot: snapshot.Bytes(), 4599 } 4600 } 4601 4602 return out, metadata, err 4603} 4604 4605func awsRestxml_deserializeOpErrorGetBucketRequestPayment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4606 var errorBuffer bytes.Buffer 4607 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4608 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4609 } 4610 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4611 4612 errorCode := "UnknownError" 4613 errorMessage := errorCode 4614 4615 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4616 UseStatusCode: true, StatusCode: response.StatusCode, 4617 }) 4618 if err != nil { 4619 return err 4620 } 4621 if hostID := errorComponents.HostID; len(hostID) != 0 { 4622 s3shared.SetHostIDMetadata(metadata, hostID) 4623 } 4624 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4625 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4626 } 4627 if len(errorComponents.Code) != 0 { 4628 errorCode = errorComponents.Code 4629 } 4630 if len(errorComponents.Message) != 0 { 4631 errorMessage = errorComponents.Message 4632 } 4633 errorBody.Seek(0, io.SeekStart) 4634 switch { 4635 default: 4636 genericError := &smithy.GenericAPIError{ 4637 Code: errorCode, 4638 Message: errorMessage, 4639 } 4640 return genericError 4641 4642 } 4643} 4644 4645func awsRestxml_deserializeOpDocumentGetBucketRequestPaymentOutput(v **GetBucketRequestPaymentOutput, decoder smithyxml.NodeDecoder) error { 4646 if v == nil { 4647 return fmt.Errorf("unexpected nil of type %T", v) 4648 } 4649 var sv *GetBucketRequestPaymentOutput 4650 if *v == nil { 4651 sv = &GetBucketRequestPaymentOutput{} 4652 } else { 4653 sv = *v 4654 } 4655 4656 for { 4657 t, done, err := decoder.Token() 4658 if err != nil { 4659 return err 4660 } 4661 if done { 4662 break 4663 } 4664 originalDecoder := decoder 4665 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4666 switch { 4667 case strings.EqualFold("Payer", t.Name.Local): 4668 val, err := decoder.Value() 4669 if err != nil { 4670 return err 4671 } 4672 if val == nil { 4673 break 4674 } 4675 { 4676 xtv := string(val) 4677 sv.Payer = types.Payer(xtv) 4678 } 4679 4680 default: 4681 // Do nothing and ignore the unexpected tag element 4682 err = decoder.Decoder.Skip() 4683 if err != nil { 4684 return err 4685 } 4686 4687 } 4688 decoder = originalDecoder 4689 } 4690 *v = sv 4691 return nil 4692} 4693 4694type awsRestxml_deserializeOpGetBucketTagging struct { 4695} 4696 4697func (*awsRestxml_deserializeOpGetBucketTagging) ID() string { 4698 return "OperationDeserializer" 4699} 4700 4701func (m *awsRestxml_deserializeOpGetBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4702 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4703) { 4704 out, metadata, err = next.HandleDeserialize(ctx, in) 4705 if err != nil { 4706 return out, metadata, err 4707 } 4708 4709 response, ok := out.RawResponse.(*smithyhttp.Response) 4710 if !ok { 4711 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4712 } 4713 4714 if response.StatusCode < 200 || response.StatusCode >= 300 { 4715 return out, metadata, awsRestxml_deserializeOpErrorGetBucketTagging(response, &metadata) 4716 } 4717 output := &GetBucketTaggingOutput{} 4718 out.Result = output 4719 4720 var buff [1024]byte 4721 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4722 body := io.TeeReader(response.Body, ringBuffer) 4723 rootDecoder := xml.NewDecoder(body) 4724 t, err := smithyxml.FetchRootElement(rootDecoder) 4725 if err == io.EOF { 4726 return out, metadata, nil 4727 } 4728 if err != nil { 4729 var snapshot bytes.Buffer 4730 io.Copy(&snapshot, ringBuffer) 4731 return out, metadata, &smithy.DeserializationError{ 4732 Err: fmt.Errorf("failed to decode response body, %w", err), 4733 Snapshot: snapshot.Bytes(), 4734 } 4735 } 4736 4737 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4738 err = awsRestxml_deserializeOpDocumentGetBucketTaggingOutput(&output, decoder) 4739 if err != nil { 4740 var snapshot bytes.Buffer 4741 io.Copy(&snapshot, ringBuffer) 4742 return out, metadata, &smithy.DeserializationError{ 4743 Err: fmt.Errorf("failed to decode response body, %w", err), 4744 Snapshot: snapshot.Bytes(), 4745 } 4746 } 4747 4748 return out, metadata, err 4749} 4750 4751func awsRestxml_deserializeOpErrorGetBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4752 var errorBuffer bytes.Buffer 4753 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4754 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4755 } 4756 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4757 4758 errorCode := "UnknownError" 4759 errorMessage := errorCode 4760 4761 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4762 UseStatusCode: true, StatusCode: response.StatusCode, 4763 }) 4764 if err != nil { 4765 return err 4766 } 4767 if hostID := errorComponents.HostID; len(hostID) != 0 { 4768 s3shared.SetHostIDMetadata(metadata, hostID) 4769 } 4770 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4771 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4772 } 4773 if len(errorComponents.Code) != 0 { 4774 errorCode = errorComponents.Code 4775 } 4776 if len(errorComponents.Message) != 0 { 4777 errorMessage = errorComponents.Message 4778 } 4779 errorBody.Seek(0, io.SeekStart) 4780 switch { 4781 default: 4782 genericError := &smithy.GenericAPIError{ 4783 Code: errorCode, 4784 Message: errorMessage, 4785 } 4786 return genericError 4787 4788 } 4789} 4790 4791func awsRestxml_deserializeOpDocumentGetBucketTaggingOutput(v **GetBucketTaggingOutput, decoder smithyxml.NodeDecoder) error { 4792 if v == nil { 4793 return fmt.Errorf("unexpected nil of type %T", v) 4794 } 4795 var sv *GetBucketTaggingOutput 4796 if *v == nil { 4797 sv = &GetBucketTaggingOutput{} 4798 } else { 4799 sv = *v 4800 } 4801 4802 for { 4803 t, done, err := decoder.Token() 4804 if err != nil { 4805 return err 4806 } 4807 if done { 4808 break 4809 } 4810 originalDecoder := decoder 4811 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4812 switch { 4813 case strings.EqualFold("TagSet", t.Name.Local): 4814 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4815 if err := awsRestxml_deserializeDocumentTagSet(&sv.TagSet, nodeDecoder); err != nil { 4816 return err 4817 } 4818 4819 default: 4820 // Do nothing and ignore the unexpected tag element 4821 err = decoder.Decoder.Skip() 4822 if err != nil { 4823 return err 4824 } 4825 4826 } 4827 decoder = originalDecoder 4828 } 4829 *v = sv 4830 return nil 4831} 4832 4833type awsRestxml_deserializeOpGetBucketVersioning struct { 4834} 4835 4836func (*awsRestxml_deserializeOpGetBucketVersioning) ID() string { 4837 return "OperationDeserializer" 4838} 4839 4840func (m *awsRestxml_deserializeOpGetBucketVersioning) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4841 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4842) { 4843 out, metadata, err = next.HandleDeserialize(ctx, in) 4844 if err != nil { 4845 return out, metadata, err 4846 } 4847 4848 response, ok := out.RawResponse.(*smithyhttp.Response) 4849 if !ok { 4850 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4851 } 4852 4853 if response.StatusCode < 200 || response.StatusCode >= 300 { 4854 return out, metadata, awsRestxml_deserializeOpErrorGetBucketVersioning(response, &metadata) 4855 } 4856 output := &GetBucketVersioningOutput{} 4857 out.Result = output 4858 4859 var buff [1024]byte 4860 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4861 body := io.TeeReader(response.Body, ringBuffer) 4862 rootDecoder := xml.NewDecoder(body) 4863 t, err := smithyxml.FetchRootElement(rootDecoder) 4864 if err == io.EOF { 4865 return out, metadata, nil 4866 } 4867 if err != nil { 4868 var snapshot bytes.Buffer 4869 io.Copy(&snapshot, ringBuffer) 4870 return out, metadata, &smithy.DeserializationError{ 4871 Err: fmt.Errorf("failed to decode response body, %w", err), 4872 Snapshot: snapshot.Bytes(), 4873 } 4874 } 4875 4876 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4877 err = awsRestxml_deserializeOpDocumentGetBucketVersioningOutput(&output, decoder) 4878 if err != nil { 4879 var snapshot bytes.Buffer 4880 io.Copy(&snapshot, ringBuffer) 4881 return out, metadata, &smithy.DeserializationError{ 4882 Err: fmt.Errorf("failed to decode response body, %w", err), 4883 Snapshot: snapshot.Bytes(), 4884 } 4885 } 4886 4887 return out, metadata, err 4888} 4889 4890func awsRestxml_deserializeOpErrorGetBucketVersioning(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4891 var errorBuffer bytes.Buffer 4892 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4893 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4894 } 4895 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4896 4897 errorCode := "UnknownError" 4898 errorMessage := errorCode 4899 4900 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4901 UseStatusCode: true, StatusCode: response.StatusCode, 4902 }) 4903 if err != nil { 4904 return err 4905 } 4906 if hostID := errorComponents.HostID; len(hostID) != 0 { 4907 s3shared.SetHostIDMetadata(metadata, hostID) 4908 } 4909 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4910 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4911 } 4912 if len(errorComponents.Code) != 0 { 4913 errorCode = errorComponents.Code 4914 } 4915 if len(errorComponents.Message) != 0 { 4916 errorMessage = errorComponents.Message 4917 } 4918 errorBody.Seek(0, io.SeekStart) 4919 switch { 4920 default: 4921 genericError := &smithy.GenericAPIError{ 4922 Code: errorCode, 4923 Message: errorMessage, 4924 } 4925 return genericError 4926 4927 } 4928} 4929 4930func awsRestxml_deserializeOpDocumentGetBucketVersioningOutput(v **GetBucketVersioningOutput, decoder smithyxml.NodeDecoder) error { 4931 if v == nil { 4932 return fmt.Errorf("unexpected nil of type %T", v) 4933 } 4934 var sv *GetBucketVersioningOutput 4935 if *v == nil { 4936 sv = &GetBucketVersioningOutput{} 4937 } else { 4938 sv = *v 4939 } 4940 4941 for { 4942 t, done, err := decoder.Token() 4943 if err != nil { 4944 return err 4945 } 4946 if done { 4947 break 4948 } 4949 originalDecoder := decoder 4950 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4951 switch { 4952 case strings.EqualFold("MfaDelete", t.Name.Local): 4953 val, err := decoder.Value() 4954 if err != nil { 4955 return err 4956 } 4957 if val == nil { 4958 break 4959 } 4960 { 4961 xtv := string(val) 4962 sv.MFADelete = types.MFADeleteStatus(xtv) 4963 } 4964 4965 case strings.EqualFold("Status", t.Name.Local): 4966 val, err := decoder.Value() 4967 if err != nil { 4968 return err 4969 } 4970 if val == nil { 4971 break 4972 } 4973 { 4974 xtv := string(val) 4975 sv.Status = types.BucketVersioningStatus(xtv) 4976 } 4977 4978 default: 4979 // Do nothing and ignore the unexpected tag element 4980 err = decoder.Decoder.Skip() 4981 if err != nil { 4982 return err 4983 } 4984 4985 } 4986 decoder = originalDecoder 4987 } 4988 *v = sv 4989 return nil 4990} 4991 4992type awsRestxml_deserializeOpGetBucketWebsite struct { 4993} 4994 4995func (*awsRestxml_deserializeOpGetBucketWebsite) ID() string { 4996 return "OperationDeserializer" 4997} 4998 4999func (m *awsRestxml_deserializeOpGetBucketWebsite) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5000 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5001) { 5002 out, metadata, err = next.HandleDeserialize(ctx, in) 5003 if err != nil { 5004 return out, metadata, err 5005 } 5006 5007 response, ok := out.RawResponse.(*smithyhttp.Response) 5008 if !ok { 5009 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5010 } 5011 5012 if response.StatusCode < 200 || response.StatusCode >= 300 { 5013 return out, metadata, awsRestxml_deserializeOpErrorGetBucketWebsite(response, &metadata) 5014 } 5015 output := &GetBucketWebsiteOutput{} 5016 out.Result = output 5017 5018 var buff [1024]byte 5019 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5020 body := io.TeeReader(response.Body, ringBuffer) 5021 rootDecoder := xml.NewDecoder(body) 5022 t, err := smithyxml.FetchRootElement(rootDecoder) 5023 if err == io.EOF { 5024 return out, metadata, nil 5025 } 5026 if err != nil { 5027 var snapshot bytes.Buffer 5028 io.Copy(&snapshot, ringBuffer) 5029 return out, metadata, &smithy.DeserializationError{ 5030 Err: fmt.Errorf("failed to decode response body, %w", err), 5031 Snapshot: snapshot.Bytes(), 5032 } 5033 } 5034 5035 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5036 err = awsRestxml_deserializeOpDocumentGetBucketWebsiteOutput(&output, decoder) 5037 if err != nil { 5038 var snapshot bytes.Buffer 5039 io.Copy(&snapshot, ringBuffer) 5040 return out, metadata, &smithy.DeserializationError{ 5041 Err: fmt.Errorf("failed to decode response body, %w", err), 5042 Snapshot: snapshot.Bytes(), 5043 } 5044 } 5045 5046 return out, metadata, err 5047} 5048 5049func awsRestxml_deserializeOpErrorGetBucketWebsite(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5050 var errorBuffer bytes.Buffer 5051 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5052 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5053 } 5054 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5055 5056 errorCode := "UnknownError" 5057 errorMessage := errorCode 5058 5059 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5060 UseStatusCode: true, StatusCode: response.StatusCode, 5061 }) 5062 if err != nil { 5063 return err 5064 } 5065 if hostID := errorComponents.HostID; len(hostID) != 0 { 5066 s3shared.SetHostIDMetadata(metadata, hostID) 5067 } 5068 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5069 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5070 } 5071 if len(errorComponents.Code) != 0 { 5072 errorCode = errorComponents.Code 5073 } 5074 if len(errorComponents.Message) != 0 { 5075 errorMessage = errorComponents.Message 5076 } 5077 errorBody.Seek(0, io.SeekStart) 5078 switch { 5079 default: 5080 genericError := &smithy.GenericAPIError{ 5081 Code: errorCode, 5082 Message: errorMessage, 5083 } 5084 return genericError 5085 5086 } 5087} 5088 5089func awsRestxml_deserializeOpDocumentGetBucketWebsiteOutput(v **GetBucketWebsiteOutput, decoder smithyxml.NodeDecoder) error { 5090 if v == nil { 5091 return fmt.Errorf("unexpected nil of type %T", v) 5092 } 5093 var sv *GetBucketWebsiteOutput 5094 if *v == nil { 5095 sv = &GetBucketWebsiteOutput{} 5096 } else { 5097 sv = *v 5098 } 5099 5100 for { 5101 t, done, err := decoder.Token() 5102 if err != nil { 5103 return err 5104 } 5105 if done { 5106 break 5107 } 5108 originalDecoder := decoder 5109 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5110 switch { 5111 case strings.EqualFold("ErrorDocument", t.Name.Local): 5112 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5113 if err := awsRestxml_deserializeDocumentErrorDocument(&sv.ErrorDocument, nodeDecoder); err != nil { 5114 return err 5115 } 5116 5117 case strings.EqualFold("IndexDocument", t.Name.Local): 5118 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5119 if err := awsRestxml_deserializeDocumentIndexDocument(&sv.IndexDocument, nodeDecoder); err != nil { 5120 return err 5121 } 5122 5123 case strings.EqualFold("RedirectAllRequestsTo", t.Name.Local): 5124 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5125 if err := awsRestxml_deserializeDocumentRedirectAllRequestsTo(&sv.RedirectAllRequestsTo, nodeDecoder); err != nil { 5126 return err 5127 } 5128 5129 case strings.EqualFold("RoutingRules", t.Name.Local): 5130 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5131 if err := awsRestxml_deserializeDocumentRoutingRules(&sv.RoutingRules, nodeDecoder); err != nil { 5132 return err 5133 } 5134 5135 default: 5136 // Do nothing and ignore the unexpected tag element 5137 err = decoder.Decoder.Skip() 5138 if err != nil { 5139 return err 5140 } 5141 5142 } 5143 decoder = originalDecoder 5144 } 5145 *v = sv 5146 return nil 5147} 5148 5149type awsRestxml_deserializeOpGetObject struct { 5150} 5151 5152func (*awsRestxml_deserializeOpGetObject) ID() string { 5153 return "OperationDeserializer" 5154} 5155 5156func (m *awsRestxml_deserializeOpGetObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5157 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5158) { 5159 out, metadata, err = next.HandleDeserialize(ctx, in) 5160 if err != nil { 5161 return out, metadata, err 5162 } 5163 5164 response, ok := out.RawResponse.(*smithyhttp.Response) 5165 if !ok { 5166 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5167 } 5168 5169 if response.StatusCode < 200 || response.StatusCode >= 300 { 5170 return out, metadata, awsRestxml_deserializeOpErrorGetObject(response, &metadata) 5171 } 5172 output := &GetObjectOutput{} 5173 out.Result = output 5174 5175 err = awsRestxml_deserializeOpHttpBindingsGetObjectOutput(output, response) 5176 if err != nil { 5177 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5178 } 5179 5180 err = awsRestxml_deserializeOpDocumentGetObjectOutput(output, response.Body) 5181 if err != nil { 5182 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 5183 } 5184 5185 return out, metadata, err 5186} 5187 5188func awsRestxml_deserializeOpErrorGetObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5189 var errorBuffer bytes.Buffer 5190 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5191 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5192 } 5193 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5194 5195 errorCode := "UnknownError" 5196 errorMessage := errorCode 5197 5198 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5199 UseStatusCode: true, StatusCode: response.StatusCode, 5200 }) 5201 if err != nil { 5202 return err 5203 } 5204 if hostID := errorComponents.HostID; len(hostID) != 0 { 5205 s3shared.SetHostIDMetadata(metadata, hostID) 5206 } 5207 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5208 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5209 } 5210 if len(errorComponents.Code) != 0 { 5211 errorCode = errorComponents.Code 5212 } 5213 if len(errorComponents.Message) != 0 { 5214 errorMessage = errorComponents.Message 5215 } 5216 errorBody.Seek(0, io.SeekStart) 5217 switch { 5218 case strings.EqualFold("InvalidObjectState", errorCode): 5219 return awsRestxml_deserializeErrorInvalidObjectState(response, errorBody) 5220 5221 case strings.EqualFold("NoSuchKey", errorCode): 5222 return awsRestxml_deserializeErrorNoSuchKey(response, errorBody) 5223 5224 default: 5225 genericError := &smithy.GenericAPIError{ 5226 Code: errorCode, 5227 Message: errorMessage, 5228 } 5229 return genericError 5230 5231 } 5232} 5233 5234func awsRestxml_deserializeOpHttpBindingsGetObjectOutput(v *GetObjectOutput, response *smithyhttp.Response) error { 5235 if v == nil { 5236 return fmt.Errorf("unsupported deserialization for nil %T", v) 5237 } 5238 5239 if headerValues := response.Header.Values("accept-ranges"); len(headerValues) != 0 { 5240 headerValues[0] = strings.TrimSpace(headerValues[0]) 5241 v.AcceptRanges = ptr.String(headerValues[0]) 5242 } 5243 5244 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 5245 headerValues[0] = strings.TrimSpace(headerValues[0]) 5246 vv, err := strconv.ParseBool(headerValues[0]) 5247 if err != nil { 5248 return err 5249 } 5250 v.BucketKeyEnabled = vv 5251 } 5252 5253 if headerValues := response.Header.Values("Cache-Control"); len(headerValues) != 0 { 5254 headerValues[0] = strings.TrimSpace(headerValues[0]) 5255 v.CacheControl = ptr.String(headerValues[0]) 5256 } 5257 5258 if headerValues := response.Header.Values("Content-Disposition"); len(headerValues) != 0 { 5259 headerValues[0] = strings.TrimSpace(headerValues[0]) 5260 v.ContentDisposition = ptr.String(headerValues[0]) 5261 } 5262 5263 if headerValues := response.Header.Values("Content-Encoding"); len(headerValues) != 0 { 5264 headerValues[0] = strings.TrimSpace(headerValues[0]) 5265 v.ContentEncoding = ptr.String(headerValues[0]) 5266 } 5267 5268 if headerValues := response.Header.Values("Content-Language"); len(headerValues) != 0 { 5269 headerValues[0] = strings.TrimSpace(headerValues[0]) 5270 v.ContentLanguage = ptr.String(headerValues[0]) 5271 } 5272 5273 if headerValues := response.Header.Values("Content-Length"); len(headerValues) != 0 { 5274 headerValues[0] = strings.TrimSpace(headerValues[0]) 5275 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 5276 if err != nil { 5277 return err 5278 } 5279 v.ContentLength = vv 5280 } 5281 5282 if headerValues := response.Header.Values("Content-Range"); len(headerValues) != 0 { 5283 headerValues[0] = strings.TrimSpace(headerValues[0]) 5284 v.ContentRange = ptr.String(headerValues[0]) 5285 } 5286 5287 if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { 5288 headerValues[0] = strings.TrimSpace(headerValues[0]) 5289 v.ContentType = ptr.String(headerValues[0]) 5290 } 5291 5292 if headerValues := response.Header.Values("x-amz-delete-marker"); len(headerValues) != 0 { 5293 headerValues[0] = strings.TrimSpace(headerValues[0]) 5294 vv, err := strconv.ParseBool(headerValues[0]) 5295 if err != nil { 5296 return err 5297 } 5298 v.DeleteMarker = vv 5299 } 5300 5301 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 5302 headerValues[0] = strings.TrimSpace(headerValues[0]) 5303 v.ETag = ptr.String(headerValues[0]) 5304 } 5305 5306 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 5307 headerValues[0] = strings.TrimSpace(headerValues[0]) 5308 v.Expiration = ptr.String(headerValues[0]) 5309 } 5310 5311 if headerValues := response.Header.Values("Expires"); len(headerValues) != 0 { 5312 headerValues[0] = strings.TrimSpace(headerValues[0]) 5313 t, err := smithytime.ParseHTTPDate(headerValues[0]) 5314 if err != nil { 5315 return err 5316 } 5317 v.Expires = ptr.Time(t) 5318 } 5319 5320 if headerValues := response.Header.Values("Last-Modified"); len(headerValues) != 0 { 5321 headerValues[0] = strings.TrimSpace(headerValues[0]) 5322 t, err := smithytime.ParseHTTPDate(headerValues[0]) 5323 if err != nil { 5324 return err 5325 } 5326 v.LastModified = ptr.Time(t) 5327 } 5328 5329 for headerKey, headerValues := range response.Header { 5330 if lenPrefix := len("x-amz-meta-"); len(headerKey) >= lenPrefix && strings.EqualFold(headerKey[:lenPrefix], "x-amz-meta-") { 5331 if v.Metadata == nil { 5332 v.Metadata = map[string]string{} 5333 } 5334 headerValues[0] = strings.TrimSpace(headerValues[0]) 5335 v.Metadata[strings.ToLower(headerKey[lenPrefix:])] = headerValues[0] 5336 } 5337 } 5338 5339 if headerValues := response.Header.Values("x-amz-missing-meta"); len(headerValues) != 0 { 5340 headerValues[0] = strings.TrimSpace(headerValues[0]) 5341 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 5342 if err != nil { 5343 return err 5344 } 5345 v.MissingMeta = int32(vv) 5346 } 5347 5348 if headerValues := response.Header.Values("x-amz-object-lock-legal-hold"); len(headerValues) != 0 { 5349 headerValues[0] = strings.TrimSpace(headerValues[0]) 5350 v.ObjectLockLegalHoldStatus = types.ObjectLockLegalHoldStatus(headerValues[0]) 5351 } 5352 5353 if headerValues := response.Header.Values("x-amz-object-lock-mode"); len(headerValues) != 0 { 5354 headerValues[0] = strings.TrimSpace(headerValues[0]) 5355 v.ObjectLockMode = types.ObjectLockMode(headerValues[0]) 5356 } 5357 5358 if headerValues := response.Header.Values("x-amz-object-lock-retain-until-date"); len(headerValues) != 0 { 5359 headerValues[0] = strings.TrimSpace(headerValues[0]) 5360 t, err := smithytime.ParseDateTime(headerValues[0]) 5361 if err != nil { 5362 return err 5363 } 5364 v.ObjectLockRetainUntilDate = ptr.Time(t) 5365 } 5366 5367 if headerValues := response.Header.Values("x-amz-mp-parts-count"); len(headerValues) != 0 { 5368 headerValues[0] = strings.TrimSpace(headerValues[0]) 5369 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 5370 if err != nil { 5371 return err 5372 } 5373 v.PartsCount = int32(vv) 5374 } 5375 5376 if headerValues := response.Header.Values("x-amz-replication-status"); len(headerValues) != 0 { 5377 headerValues[0] = strings.TrimSpace(headerValues[0]) 5378 v.ReplicationStatus = types.ReplicationStatus(headerValues[0]) 5379 } 5380 5381 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 5382 headerValues[0] = strings.TrimSpace(headerValues[0]) 5383 v.RequestCharged = types.RequestCharged(headerValues[0]) 5384 } 5385 5386 if headerValues := response.Header.Values("x-amz-restore"); len(headerValues) != 0 { 5387 headerValues[0] = strings.TrimSpace(headerValues[0]) 5388 v.Restore = ptr.String(headerValues[0]) 5389 } 5390 5391 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 5392 headerValues[0] = strings.TrimSpace(headerValues[0]) 5393 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 5394 } 5395 5396 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 5397 headerValues[0] = strings.TrimSpace(headerValues[0]) 5398 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 5399 } 5400 5401 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 5402 headerValues[0] = strings.TrimSpace(headerValues[0]) 5403 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 5404 } 5405 5406 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 5407 headerValues[0] = strings.TrimSpace(headerValues[0]) 5408 v.SSEKMSKeyId = ptr.String(headerValues[0]) 5409 } 5410 5411 if headerValues := response.Header.Values("x-amz-storage-class"); len(headerValues) != 0 { 5412 headerValues[0] = strings.TrimSpace(headerValues[0]) 5413 v.StorageClass = types.StorageClass(headerValues[0]) 5414 } 5415 5416 if headerValues := response.Header.Values("x-amz-tagging-count"); len(headerValues) != 0 { 5417 headerValues[0] = strings.TrimSpace(headerValues[0]) 5418 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 5419 if err != nil { 5420 return err 5421 } 5422 v.TagCount = int32(vv) 5423 } 5424 5425 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 5426 headerValues[0] = strings.TrimSpace(headerValues[0]) 5427 v.VersionId = ptr.String(headerValues[0]) 5428 } 5429 5430 if headerValues := response.Header.Values("x-amz-website-redirect-location"); len(headerValues) != 0 { 5431 headerValues[0] = strings.TrimSpace(headerValues[0]) 5432 v.WebsiteRedirectLocation = ptr.String(headerValues[0]) 5433 } 5434 5435 return nil 5436} 5437func awsRestxml_deserializeOpDocumentGetObjectOutput(v *GetObjectOutput, body io.ReadCloser) error { 5438 if v == nil { 5439 return fmt.Errorf("unsupported deserialization of nil %T", v) 5440 } 5441 v.Body = body 5442 return nil 5443} 5444 5445type awsRestxml_deserializeOpGetObjectAcl struct { 5446} 5447 5448func (*awsRestxml_deserializeOpGetObjectAcl) ID() string { 5449 return "OperationDeserializer" 5450} 5451 5452func (m *awsRestxml_deserializeOpGetObjectAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5453 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5454) { 5455 out, metadata, err = next.HandleDeserialize(ctx, in) 5456 if err != nil { 5457 return out, metadata, err 5458 } 5459 5460 response, ok := out.RawResponse.(*smithyhttp.Response) 5461 if !ok { 5462 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5463 } 5464 5465 if response.StatusCode < 200 || response.StatusCode >= 300 { 5466 return out, metadata, awsRestxml_deserializeOpErrorGetObjectAcl(response, &metadata) 5467 } 5468 output := &GetObjectAclOutput{} 5469 out.Result = output 5470 5471 err = awsRestxml_deserializeOpHttpBindingsGetObjectAclOutput(output, response) 5472 if err != nil { 5473 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5474 } 5475 5476 var buff [1024]byte 5477 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5478 body := io.TeeReader(response.Body, ringBuffer) 5479 rootDecoder := xml.NewDecoder(body) 5480 t, err := smithyxml.FetchRootElement(rootDecoder) 5481 if err == io.EOF { 5482 return out, metadata, nil 5483 } 5484 if err != nil { 5485 var snapshot bytes.Buffer 5486 io.Copy(&snapshot, ringBuffer) 5487 return out, metadata, &smithy.DeserializationError{ 5488 Err: fmt.Errorf("failed to decode response body, %w", err), 5489 Snapshot: snapshot.Bytes(), 5490 } 5491 } 5492 5493 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5494 err = awsRestxml_deserializeOpDocumentGetObjectAclOutput(&output, decoder) 5495 if err != nil { 5496 var snapshot bytes.Buffer 5497 io.Copy(&snapshot, ringBuffer) 5498 return out, metadata, &smithy.DeserializationError{ 5499 Err: fmt.Errorf("failed to decode response body, %w", err), 5500 Snapshot: snapshot.Bytes(), 5501 } 5502 } 5503 5504 return out, metadata, err 5505} 5506 5507func awsRestxml_deserializeOpErrorGetObjectAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5508 var errorBuffer bytes.Buffer 5509 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5510 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5511 } 5512 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5513 5514 errorCode := "UnknownError" 5515 errorMessage := errorCode 5516 5517 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5518 UseStatusCode: true, StatusCode: response.StatusCode, 5519 }) 5520 if err != nil { 5521 return err 5522 } 5523 if hostID := errorComponents.HostID; len(hostID) != 0 { 5524 s3shared.SetHostIDMetadata(metadata, hostID) 5525 } 5526 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5527 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5528 } 5529 if len(errorComponents.Code) != 0 { 5530 errorCode = errorComponents.Code 5531 } 5532 if len(errorComponents.Message) != 0 { 5533 errorMessage = errorComponents.Message 5534 } 5535 errorBody.Seek(0, io.SeekStart) 5536 switch { 5537 case strings.EqualFold("NoSuchKey", errorCode): 5538 return awsRestxml_deserializeErrorNoSuchKey(response, errorBody) 5539 5540 default: 5541 genericError := &smithy.GenericAPIError{ 5542 Code: errorCode, 5543 Message: errorMessage, 5544 } 5545 return genericError 5546 5547 } 5548} 5549 5550func awsRestxml_deserializeOpHttpBindingsGetObjectAclOutput(v *GetObjectAclOutput, response *smithyhttp.Response) error { 5551 if v == nil { 5552 return fmt.Errorf("unsupported deserialization for nil %T", v) 5553 } 5554 5555 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 5556 headerValues[0] = strings.TrimSpace(headerValues[0]) 5557 v.RequestCharged = types.RequestCharged(headerValues[0]) 5558 } 5559 5560 return nil 5561} 5562func awsRestxml_deserializeOpDocumentGetObjectAclOutput(v **GetObjectAclOutput, decoder smithyxml.NodeDecoder) error { 5563 if v == nil { 5564 return fmt.Errorf("unexpected nil of type %T", v) 5565 } 5566 var sv *GetObjectAclOutput 5567 if *v == nil { 5568 sv = &GetObjectAclOutput{} 5569 } else { 5570 sv = *v 5571 } 5572 5573 for { 5574 t, done, err := decoder.Token() 5575 if err != nil { 5576 return err 5577 } 5578 if done { 5579 break 5580 } 5581 originalDecoder := decoder 5582 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5583 switch { 5584 case strings.EqualFold("AccessControlList", t.Name.Local): 5585 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5586 if err := awsRestxml_deserializeDocumentGrants(&sv.Grants, nodeDecoder); err != nil { 5587 return err 5588 } 5589 5590 case strings.EqualFold("Owner", t.Name.Local): 5591 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5592 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 5593 return err 5594 } 5595 5596 default: 5597 // Do nothing and ignore the unexpected tag element 5598 err = decoder.Decoder.Skip() 5599 if err != nil { 5600 return err 5601 } 5602 5603 } 5604 decoder = originalDecoder 5605 } 5606 *v = sv 5607 return nil 5608} 5609 5610type awsRestxml_deserializeOpGetObjectLegalHold struct { 5611} 5612 5613func (*awsRestxml_deserializeOpGetObjectLegalHold) ID() string { 5614 return "OperationDeserializer" 5615} 5616 5617func (m *awsRestxml_deserializeOpGetObjectLegalHold) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5619) { 5620 out, metadata, err = next.HandleDeserialize(ctx, in) 5621 if err != nil { 5622 return out, metadata, err 5623 } 5624 5625 response, ok := out.RawResponse.(*smithyhttp.Response) 5626 if !ok { 5627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5628 } 5629 5630 if response.StatusCode < 200 || response.StatusCode >= 300 { 5631 return out, metadata, awsRestxml_deserializeOpErrorGetObjectLegalHold(response, &metadata) 5632 } 5633 output := &GetObjectLegalHoldOutput{} 5634 out.Result = output 5635 5636 var buff [1024]byte 5637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5638 body := io.TeeReader(response.Body, ringBuffer) 5639 rootDecoder := xml.NewDecoder(body) 5640 t, err := smithyxml.FetchRootElement(rootDecoder) 5641 if err == io.EOF { 5642 return out, metadata, nil 5643 } 5644 if err != nil { 5645 var snapshot bytes.Buffer 5646 io.Copy(&snapshot, ringBuffer) 5647 return out, metadata, &smithy.DeserializationError{ 5648 Err: fmt.Errorf("failed to decode response body, %w", err), 5649 Snapshot: snapshot.Bytes(), 5650 } 5651 } 5652 5653 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5654 err = awsRestxml_deserializeDocumentObjectLockLegalHold(&output.LegalHold, decoder) 5655 if err != nil { 5656 var snapshot bytes.Buffer 5657 io.Copy(&snapshot, ringBuffer) 5658 return out, metadata, &smithy.DeserializationError{ 5659 Err: fmt.Errorf("failed to decode response body, %w", err), 5660 Snapshot: snapshot.Bytes(), 5661 } 5662 } 5663 5664 return out, metadata, err 5665} 5666 5667func awsRestxml_deserializeOpErrorGetObjectLegalHold(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5668 var errorBuffer bytes.Buffer 5669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5671 } 5672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5673 5674 errorCode := "UnknownError" 5675 errorMessage := errorCode 5676 5677 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5678 UseStatusCode: true, StatusCode: response.StatusCode, 5679 }) 5680 if err != nil { 5681 return err 5682 } 5683 if hostID := errorComponents.HostID; len(hostID) != 0 { 5684 s3shared.SetHostIDMetadata(metadata, hostID) 5685 } 5686 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5687 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5688 } 5689 if len(errorComponents.Code) != 0 { 5690 errorCode = errorComponents.Code 5691 } 5692 if len(errorComponents.Message) != 0 { 5693 errorMessage = errorComponents.Message 5694 } 5695 errorBody.Seek(0, io.SeekStart) 5696 switch { 5697 default: 5698 genericError := &smithy.GenericAPIError{ 5699 Code: errorCode, 5700 Message: errorMessage, 5701 } 5702 return genericError 5703 5704 } 5705} 5706 5707func awsRestxml_deserializeOpDocumentGetObjectLegalHoldOutput(v **GetObjectLegalHoldOutput, decoder smithyxml.NodeDecoder) error { 5708 if v == nil { 5709 return fmt.Errorf("unexpected nil of type %T", v) 5710 } 5711 var sv *GetObjectLegalHoldOutput 5712 if *v == nil { 5713 sv = &GetObjectLegalHoldOutput{} 5714 } else { 5715 sv = *v 5716 } 5717 5718 for { 5719 t, done, err := decoder.Token() 5720 if err != nil { 5721 return err 5722 } 5723 if done { 5724 break 5725 } 5726 originalDecoder := decoder 5727 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5728 switch { 5729 case strings.EqualFold("LegalHold", t.Name.Local): 5730 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5731 if err := awsRestxml_deserializeDocumentObjectLockLegalHold(&sv.LegalHold, nodeDecoder); err != nil { 5732 return err 5733 } 5734 5735 default: 5736 // Do nothing and ignore the unexpected tag element 5737 err = decoder.Decoder.Skip() 5738 if err != nil { 5739 return err 5740 } 5741 5742 } 5743 decoder = originalDecoder 5744 } 5745 *v = sv 5746 return nil 5747} 5748 5749type awsRestxml_deserializeOpGetObjectLockConfiguration struct { 5750} 5751 5752func (*awsRestxml_deserializeOpGetObjectLockConfiguration) ID() string { 5753 return "OperationDeserializer" 5754} 5755 5756func (m *awsRestxml_deserializeOpGetObjectLockConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5757 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5758) { 5759 out, metadata, err = next.HandleDeserialize(ctx, in) 5760 if err != nil { 5761 return out, metadata, err 5762 } 5763 5764 response, ok := out.RawResponse.(*smithyhttp.Response) 5765 if !ok { 5766 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5767 } 5768 5769 if response.StatusCode < 200 || response.StatusCode >= 300 { 5770 return out, metadata, awsRestxml_deserializeOpErrorGetObjectLockConfiguration(response, &metadata) 5771 } 5772 output := &GetObjectLockConfigurationOutput{} 5773 out.Result = output 5774 5775 var buff [1024]byte 5776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5777 body := io.TeeReader(response.Body, ringBuffer) 5778 rootDecoder := xml.NewDecoder(body) 5779 t, err := smithyxml.FetchRootElement(rootDecoder) 5780 if err == io.EOF { 5781 return out, metadata, nil 5782 } 5783 if err != nil { 5784 var snapshot bytes.Buffer 5785 io.Copy(&snapshot, ringBuffer) 5786 return out, metadata, &smithy.DeserializationError{ 5787 Err: fmt.Errorf("failed to decode response body, %w", err), 5788 Snapshot: snapshot.Bytes(), 5789 } 5790 } 5791 5792 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5793 err = awsRestxml_deserializeDocumentObjectLockConfiguration(&output.ObjectLockConfiguration, decoder) 5794 if err != nil { 5795 var snapshot bytes.Buffer 5796 io.Copy(&snapshot, ringBuffer) 5797 return out, metadata, &smithy.DeserializationError{ 5798 Err: fmt.Errorf("failed to decode response body, %w", err), 5799 Snapshot: snapshot.Bytes(), 5800 } 5801 } 5802 5803 return out, metadata, err 5804} 5805 5806func awsRestxml_deserializeOpErrorGetObjectLockConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5807 var errorBuffer bytes.Buffer 5808 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5809 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5810 } 5811 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5812 5813 errorCode := "UnknownError" 5814 errorMessage := errorCode 5815 5816 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5817 UseStatusCode: true, StatusCode: response.StatusCode, 5818 }) 5819 if err != nil { 5820 return err 5821 } 5822 if hostID := errorComponents.HostID; len(hostID) != 0 { 5823 s3shared.SetHostIDMetadata(metadata, hostID) 5824 } 5825 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5826 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5827 } 5828 if len(errorComponents.Code) != 0 { 5829 errorCode = errorComponents.Code 5830 } 5831 if len(errorComponents.Message) != 0 { 5832 errorMessage = errorComponents.Message 5833 } 5834 errorBody.Seek(0, io.SeekStart) 5835 switch { 5836 default: 5837 genericError := &smithy.GenericAPIError{ 5838 Code: errorCode, 5839 Message: errorMessage, 5840 } 5841 return genericError 5842 5843 } 5844} 5845 5846func awsRestxml_deserializeOpDocumentGetObjectLockConfigurationOutput(v **GetObjectLockConfigurationOutput, decoder smithyxml.NodeDecoder) error { 5847 if v == nil { 5848 return fmt.Errorf("unexpected nil of type %T", v) 5849 } 5850 var sv *GetObjectLockConfigurationOutput 5851 if *v == nil { 5852 sv = &GetObjectLockConfigurationOutput{} 5853 } else { 5854 sv = *v 5855 } 5856 5857 for { 5858 t, done, err := decoder.Token() 5859 if err != nil { 5860 return err 5861 } 5862 if done { 5863 break 5864 } 5865 originalDecoder := decoder 5866 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5867 switch { 5868 case strings.EqualFold("ObjectLockConfiguration", t.Name.Local): 5869 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5870 if err := awsRestxml_deserializeDocumentObjectLockConfiguration(&sv.ObjectLockConfiguration, nodeDecoder); err != nil { 5871 return err 5872 } 5873 5874 default: 5875 // Do nothing and ignore the unexpected tag element 5876 err = decoder.Decoder.Skip() 5877 if err != nil { 5878 return err 5879 } 5880 5881 } 5882 decoder = originalDecoder 5883 } 5884 *v = sv 5885 return nil 5886} 5887 5888type awsRestxml_deserializeOpGetObjectRetention struct { 5889} 5890 5891func (*awsRestxml_deserializeOpGetObjectRetention) ID() string { 5892 return "OperationDeserializer" 5893} 5894 5895func (m *awsRestxml_deserializeOpGetObjectRetention) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5896 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5897) { 5898 out, metadata, err = next.HandleDeserialize(ctx, in) 5899 if err != nil { 5900 return out, metadata, err 5901 } 5902 5903 response, ok := out.RawResponse.(*smithyhttp.Response) 5904 if !ok { 5905 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5906 } 5907 5908 if response.StatusCode < 200 || response.StatusCode >= 300 { 5909 return out, metadata, awsRestxml_deserializeOpErrorGetObjectRetention(response, &metadata) 5910 } 5911 output := &GetObjectRetentionOutput{} 5912 out.Result = output 5913 5914 var buff [1024]byte 5915 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5916 body := io.TeeReader(response.Body, ringBuffer) 5917 rootDecoder := xml.NewDecoder(body) 5918 t, err := smithyxml.FetchRootElement(rootDecoder) 5919 if err == io.EOF { 5920 return out, metadata, nil 5921 } 5922 if err != nil { 5923 var snapshot bytes.Buffer 5924 io.Copy(&snapshot, ringBuffer) 5925 return out, metadata, &smithy.DeserializationError{ 5926 Err: fmt.Errorf("failed to decode response body, %w", err), 5927 Snapshot: snapshot.Bytes(), 5928 } 5929 } 5930 5931 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5932 err = awsRestxml_deserializeDocumentObjectLockRetention(&output.Retention, decoder) 5933 if err != nil { 5934 var snapshot bytes.Buffer 5935 io.Copy(&snapshot, ringBuffer) 5936 return out, metadata, &smithy.DeserializationError{ 5937 Err: fmt.Errorf("failed to decode response body, %w", err), 5938 Snapshot: snapshot.Bytes(), 5939 } 5940 } 5941 5942 return out, metadata, err 5943} 5944 5945func awsRestxml_deserializeOpErrorGetObjectRetention(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5946 var errorBuffer bytes.Buffer 5947 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5948 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5949 } 5950 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5951 5952 errorCode := "UnknownError" 5953 errorMessage := errorCode 5954 5955 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5956 UseStatusCode: true, StatusCode: response.StatusCode, 5957 }) 5958 if err != nil { 5959 return err 5960 } 5961 if hostID := errorComponents.HostID; len(hostID) != 0 { 5962 s3shared.SetHostIDMetadata(metadata, hostID) 5963 } 5964 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5965 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5966 } 5967 if len(errorComponents.Code) != 0 { 5968 errorCode = errorComponents.Code 5969 } 5970 if len(errorComponents.Message) != 0 { 5971 errorMessage = errorComponents.Message 5972 } 5973 errorBody.Seek(0, io.SeekStart) 5974 switch { 5975 default: 5976 genericError := &smithy.GenericAPIError{ 5977 Code: errorCode, 5978 Message: errorMessage, 5979 } 5980 return genericError 5981 5982 } 5983} 5984 5985func awsRestxml_deserializeOpDocumentGetObjectRetentionOutput(v **GetObjectRetentionOutput, decoder smithyxml.NodeDecoder) error { 5986 if v == nil { 5987 return fmt.Errorf("unexpected nil of type %T", v) 5988 } 5989 var sv *GetObjectRetentionOutput 5990 if *v == nil { 5991 sv = &GetObjectRetentionOutput{} 5992 } else { 5993 sv = *v 5994 } 5995 5996 for { 5997 t, done, err := decoder.Token() 5998 if err != nil { 5999 return err 6000 } 6001 if done { 6002 break 6003 } 6004 originalDecoder := decoder 6005 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6006 switch { 6007 case strings.EqualFold("Retention", t.Name.Local): 6008 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6009 if err := awsRestxml_deserializeDocumentObjectLockRetention(&sv.Retention, nodeDecoder); err != nil { 6010 return err 6011 } 6012 6013 default: 6014 // Do nothing and ignore the unexpected tag element 6015 err = decoder.Decoder.Skip() 6016 if err != nil { 6017 return err 6018 } 6019 6020 } 6021 decoder = originalDecoder 6022 } 6023 *v = sv 6024 return nil 6025} 6026 6027type awsRestxml_deserializeOpGetObjectTagging struct { 6028} 6029 6030func (*awsRestxml_deserializeOpGetObjectTagging) ID() string { 6031 return "OperationDeserializer" 6032} 6033 6034func (m *awsRestxml_deserializeOpGetObjectTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6035 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6036) { 6037 out, metadata, err = next.HandleDeserialize(ctx, in) 6038 if err != nil { 6039 return out, metadata, err 6040 } 6041 6042 response, ok := out.RawResponse.(*smithyhttp.Response) 6043 if !ok { 6044 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6045 } 6046 6047 if response.StatusCode < 200 || response.StatusCode >= 300 { 6048 return out, metadata, awsRestxml_deserializeOpErrorGetObjectTagging(response, &metadata) 6049 } 6050 output := &GetObjectTaggingOutput{} 6051 out.Result = output 6052 6053 err = awsRestxml_deserializeOpHttpBindingsGetObjectTaggingOutput(output, response) 6054 if err != nil { 6055 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 6056 } 6057 6058 var buff [1024]byte 6059 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6060 body := io.TeeReader(response.Body, ringBuffer) 6061 rootDecoder := xml.NewDecoder(body) 6062 t, err := smithyxml.FetchRootElement(rootDecoder) 6063 if err == io.EOF { 6064 return out, metadata, nil 6065 } 6066 if err != nil { 6067 var snapshot bytes.Buffer 6068 io.Copy(&snapshot, ringBuffer) 6069 return out, metadata, &smithy.DeserializationError{ 6070 Err: fmt.Errorf("failed to decode response body, %w", err), 6071 Snapshot: snapshot.Bytes(), 6072 } 6073 } 6074 6075 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6076 err = awsRestxml_deserializeOpDocumentGetObjectTaggingOutput(&output, decoder) 6077 if err != nil { 6078 var snapshot bytes.Buffer 6079 io.Copy(&snapshot, ringBuffer) 6080 return out, metadata, &smithy.DeserializationError{ 6081 Err: fmt.Errorf("failed to decode response body, %w", err), 6082 Snapshot: snapshot.Bytes(), 6083 } 6084 } 6085 6086 return out, metadata, err 6087} 6088 6089func awsRestxml_deserializeOpErrorGetObjectTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6090 var errorBuffer bytes.Buffer 6091 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6092 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6093 } 6094 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6095 6096 errorCode := "UnknownError" 6097 errorMessage := errorCode 6098 6099 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6100 UseStatusCode: true, StatusCode: response.StatusCode, 6101 }) 6102 if err != nil { 6103 return err 6104 } 6105 if hostID := errorComponents.HostID; len(hostID) != 0 { 6106 s3shared.SetHostIDMetadata(metadata, hostID) 6107 } 6108 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6109 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6110 } 6111 if len(errorComponents.Code) != 0 { 6112 errorCode = errorComponents.Code 6113 } 6114 if len(errorComponents.Message) != 0 { 6115 errorMessage = errorComponents.Message 6116 } 6117 errorBody.Seek(0, io.SeekStart) 6118 switch { 6119 default: 6120 genericError := &smithy.GenericAPIError{ 6121 Code: errorCode, 6122 Message: errorMessage, 6123 } 6124 return genericError 6125 6126 } 6127} 6128 6129func awsRestxml_deserializeOpHttpBindingsGetObjectTaggingOutput(v *GetObjectTaggingOutput, response *smithyhttp.Response) error { 6130 if v == nil { 6131 return fmt.Errorf("unsupported deserialization for nil %T", v) 6132 } 6133 6134 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 6135 headerValues[0] = strings.TrimSpace(headerValues[0]) 6136 v.VersionId = ptr.String(headerValues[0]) 6137 } 6138 6139 return nil 6140} 6141func awsRestxml_deserializeOpDocumentGetObjectTaggingOutput(v **GetObjectTaggingOutput, decoder smithyxml.NodeDecoder) error { 6142 if v == nil { 6143 return fmt.Errorf("unexpected nil of type %T", v) 6144 } 6145 var sv *GetObjectTaggingOutput 6146 if *v == nil { 6147 sv = &GetObjectTaggingOutput{} 6148 } else { 6149 sv = *v 6150 } 6151 6152 for { 6153 t, done, err := decoder.Token() 6154 if err != nil { 6155 return err 6156 } 6157 if done { 6158 break 6159 } 6160 originalDecoder := decoder 6161 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6162 switch { 6163 case strings.EqualFold("TagSet", t.Name.Local): 6164 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6165 if err := awsRestxml_deserializeDocumentTagSet(&sv.TagSet, nodeDecoder); err != nil { 6166 return err 6167 } 6168 6169 default: 6170 // Do nothing and ignore the unexpected tag element 6171 err = decoder.Decoder.Skip() 6172 if err != nil { 6173 return err 6174 } 6175 6176 } 6177 decoder = originalDecoder 6178 } 6179 *v = sv 6180 return nil 6181} 6182 6183type awsRestxml_deserializeOpGetObjectTorrent struct { 6184} 6185 6186func (*awsRestxml_deserializeOpGetObjectTorrent) ID() string { 6187 return "OperationDeserializer" 6188} 6189 6190func (m *awsRestxml_deserializeOpGetObjectTorrent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6191 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6192) { 6193 out, metadata, err = next.HandleDeserialize(ctx, in) 6194 if err != nil { 6195 return out, metadata, err 6196 } 6197 6198 response, ok := out.RawResponse.(*smithyhttp.Response) 6199 if !ok { 6200 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6201 } 6202 6203 if response.StatusCode < 200 || response.StatusCode >= 300 { 6204 return out, metadata, awsRestxml_deserializeOpErrorGetObjectTorrent(response, &metadata) 6205 } 6206 output := &GetObjectTorrentOutput{} 6207 out.Result = output 6208 6209 err = awsRestxml_deserializeOpHttpBindingsGetObjectTorrentOutput(output, response) 6210 if err != nil { 6211 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 6212 } 6213 6214 err = awsRestxml_deserializeOpDocumentGetObjectTorrentOutput(output, response.Body) 6215 if err != nil { 6216 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 6217 } 6218 6219 return out, metadata, err 6220} 6221 6222func awsRestxml_deserializeOpErrorGetObjectTorrent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6223 var errorBuffer bytes.Buffer 6224 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6225 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6226 } 6227 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6228 6229 errorCode := "UnknownError" 6230 errorMessage := errorCode 6231 6232 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6233 UseStatusCode: true, StatusCode: response.StatusCode, 6234 }) 6235 if err != nil { 6236 return err 6237 } 6238 if hostID := errorComponents.HostID; len(hostID) != 0 { 6239 s3shared.SetHostIDMetadata(metadata, hostID) 6240 } 6241 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6242 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6243 } 6244 if len(errorComponents.Code) != 0 { 6245 errorCode = errorComponents.Code 6246 } 6247 if len(errorComponents.Message) != 0 { 6248 errorMessage = errorComponents.Message 6249 } 6250 errorBody.Seek(0, io.SeekStart) 6251 switch { 6252 default: 6253 genericError := &smithy.GenericAPIError{ 6254 Code: errorCode, 6255 Message: errorMessage, 6256 } 6257 return genericError 6258 6259 } 6260} 6261 6262func awsRestxml_deserializeOpHttpBindingsGetObjectTorrentOutput(v *GetObjectTorrentOutput, response *smithyhttp.Response) error { 6263 if v == nil { 6264 return fmt.Errorf("unsupported deserialization for nil %T", v) 6265 } 6266 6267 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 6268 headerValues[0] = strings.TrimSpace(headerValues[0]) 6269 v.RequestCharged = types.RequestCharged(headerValues[0]) 6270 } 6271 6272 return nil 6273} 6274func awsRestxml_deserializeOpDocumentGetObjectTorrentOutput(v *GetObjectTorrentOutput, body io.ReadCloser) error { 6275 if v == nil { 6276 return fmt.Errorf("unsupported deserialization of nil %T", v) 6277 } 6278 v.Body = body 6279 return nil 6280} 6281 6282type awsRestxml_deserializeOpGetPublicAccessBlock struct { 6283} 6284 6285func (*awsRestxml_deserializeOpGetPublicAccessBlock) ID() string { 6286 return "OperationDeserializer" 6287} 6288 6289func (m *awsRestxml_deserializeOpGetPublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6290 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6291) { 6292 out, metadata, err = next.HandleDeserialize(ctx, in) 6293 if err != nil { 6294 return out, metadata, err 6295 } 6296 6297 response, ok := out.RawResponse.(*smithyhttp.Response) 6298 if !ok { 6299 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6300 } 6301 6302 if response.StatusCode < 200 || response.StatusCode >= 300 { 6303 return out, metadata, awsRestxml_deserializeOpErrorGetPublicAccessBlock(response, &metadata) 6304 } 6305 output := &GetPublicAccessBlockOutput{} 6306 out.Result = output 6307 6308 var buff [1024]byte 6309 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6310 body := io.TeeReader(response.Body, ringBuffer) 6311 rootDecoder := xml.NewDecoder(body) 6312 t, err := smithyxml.FetchRootElement(rootDecoder) 6313 if err == io.EOF { 6314 return out, metadata, nil 6315 } 6316 if err != nil { 6317 var snapshot bytes.Buffer 6318 io.Copy(&snapshot, ringBuffer) 6319 return out, metadata, &smithy.DeserializationError{ 6320 Err: fmt.Errorf("failed to decode response body, %w", err), 6321 Snapshot: snapshot.Bytes(), 6322 } 6323 } 6324 6325 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6326 err = awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&output.PublicAccessBlockConfiguration, decoder) 6327 if err != nil { 6328 var snapshot bytes.Buffer 6329 io.Copy(&snapshot, ringBuffer) 6330 return out, metadata, &smithy.DeserializationError{ 6331 Err: fmt.Errorf("failed to decode response body, %w", err), 6332 Snapshot: snapshot.Bytes(), 6333 } 6334 } 6335 6336 return out, metadata, err 6337} 6338 6339func awsRestxml_deserializeOpErrorGetPublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6340 var errorBuffer bytes.Buffer 6341 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6342 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6343 } 6344 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6345 6346 errorCode := "UnknownError" 6347 errorMessage := errorCode 6348 6349 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6350 UseStatusCode: true, StatusCode: response.StatusCode, 6351 }) 6352 if err != nil { 6353 return err 6354 } 6355 if hostID := errorComponents.HostID; len(hostID) != 0 { 6356 s3shared.SetHostIDMetadata(metadata, hostID) 6357 } 6358 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6359 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6360 } 6361 if len(errorComponents.Code) != 0 { 6362 errorCode = errorComponents.Code 6363 } 6364 if len(errorComponents.Message) != 0 { 6365 errorMessage = errorComponents.Message 6366 } 6367 errorBody.Seek(0, io.SeekStart) 6368 switch { 6369 default: 6370 genericError := &smithy.GenericAPIError{ 6371 Code: errorCode, 6372 Message: errorMessage, 6373 } 6374 return genericError 6375 6376 } 6377} 6378 6379func awsRestxml_deserializeOpDocumentGetPublicAccessBlockOutput(v **GetPublicAccessBlockOutput, decoder smithyxml.NodeDecoder) error { 6380 if v == nil { 6381 return fmt.Errorf("unexpected nil of type %T", v) 6382 } 6383 var sv *GetPublicAccessBlockOutput 6384 if *v == nil { 6385 sv = &GetPublicAccessBlockOutput{} 6386 } else { 6387 sv = *v 6388 } 6389 6390 for { 6391 t, done, err := decoder.Token() 6392 if err != nil { 6393 return err 6394 } 6395 if done { 6396 break 6397 } 6398 originalDecoder := decoder 6399 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6400 switch { 6401 case strings.EqualFold("PublicAccessBlockConfiguration", t.Name.Local): 6402 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6403 if err := awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&sv.PublicAccessBlockConfiguration, nodeDecoder); err != nil { 6404 return err 6405 } 6406 6407 default: 6408 // Do nothing and ignore the unexpected tag element 6409 err = decoder.Decoder.Skip() 6410 if err != nil { 6411 return err 6412 } 6413 6414 } 6415 decoder = originalDecoder 6416 } 6417 *v = sv 6418 return nil 6419} 6420 6421type awsRestxml_deserializeOpHeadBucket struct { 6422} 6423 6424func (*awsRestxml_deserializeOpHeadBucket) ID() string { 6425 return "OperationDeserializer" 6426} 6427 6428func (m *awsRestxml_deserializeOpHeadBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6429 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6430) { 6431 out, metadata, err = next.HandleDeserialize(ctx, in) 6432 if err != nil { 6433 return out, metadata, err 6434 } 6435 6436 response, ok := out.RawResponse.(*smithyhttp.Response) 6437 if !ok { 6438 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6439 } 6440 6441 if response.StatusCode < 200 || response.StatusCode >= 300 { 6442 return out, metadata, awsRestxml_deserializeOpErrorHeadBucket(response, &metadata) 6443 } 6444 output := &HeadBucketOutput{} 6445 out.Result = output 6446 6447 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6448 return out, metadata, &smithy.DeserializationError{ 6449 Err: fmt.Errorf("failed to discard response body, %w", err), 6450 } 6451 } 6452 6453 return out, metadata, err 6454} 6455 6456func awsRestxml_deserializeOpErrorHeadBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6457 var errorBuffer bytes.Buffer 6458 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6459 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6460 } 6461 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6462 6463 errorCode := "UnknownError" 6464 errorMessage := errorCode 6465 6466 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6467 UseStatusCode: true, StatusCode: response.StatusCode, 6468 }) 6469 if err != nil { 6470 return err 6471 } 6472 if hostID := errorComponents.HostID; len(hostID) != 0 { 6473 s3shared.SetHostIDMetadata(metadata, hostID) 6474 } 6475 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6476 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6477 } 6478 if len(errorComponents.Code) != 0 { 6479 errorCode = errorComponents.Code 6480 } 6481 if len(errorComponents.Message) != 0 { 6482 errorMessage = errorComponents.Message 6483 } 6484 errorBody.Seek(0, io.SeekStart) 6485 switch { 6486 case strings.EqualFold("NotFound", errorCode): 6487 return awsRestxml_deserializeErrorNotFound(response, errorBody) 6488 6489 default: 6490 genericError := &smithy.GenericAPIError{ 6491 Code: errorCode, 6492 Message: errorMessage, 6493 } 6494 return genericError 6495 6496 } 6497} 6498 6499type awsRestxml_deserializeOpHeadObject struct { 6500} 6501 6502func (*awsRestxml_deserializeOpHeadObject) ID() string { 6503 return "OperationDeserializer" 6504} 6505 6506func (m *awsRestxml_deserializeOpHeadObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6507 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6508) { 6509 out, metadata, err = next.HandleDeserialize(ctx, in) 6510 if err != nil { 6511 return out, metadata, err 6512 } 6513 6514 response, ok := out.RawResponse.(*smithyhttp.Response) 6515 if !ok { 6516 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6517 } 6518 6519 if response.StatusCode < 200 || response.StatusCode >= 300 { 6520 return out, metadata, awsRestxml_deserializeOpErrorHeadObject(response, &metadata) 6521 } 6522 output := &HeadObjectOutput{} 6523 out.Result = output 6524 6525 err = awsRestxml_deserializeOpHttpBindingsHeadObjectOutput(output, response) 6526 if err != nil { 6527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 6528 } 6529 6530 return out, metadata, err 6531} 6532 6533func awsRestxml_deserializeOpErrorHeadObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6534 var errorBuffer bytes.Buffer 6535 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6536 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6537 } 6538 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6539 6540 errorCode := "UnknownError" 6541 errorMessage := errorCode 6542 6543 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6544 UseStatusCode: true, StatusCode: response.StatusCode, 6545 }) 6546 if err != nil { 6547 return err 6548 } 6549 if hostID := errorComponents.HostID; len(hostID) != 0 { 6550 s3shared.SetHostIDMetadata(metadata, hostID) 6551 } 6552 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6553 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6554 } 6555 if len(errorComponents.Code) != 0 { 6556 errorCode = errorComponents.Code 6557 } 6558 if len(errorComponents.Message) != 0 { 6559 errorMessage = errorComponents.Message 6560 } 6561 errorBody.Seek(0, io.SeekStart) 6562 switch { 6563 default: 6564 genericError := &smithy.GenericAPIError{ 6565 Code: errorCode, 6566 Message: errorMessage, 6567 } 6568 return genericError 6569 6570 } 6571} 6572 6573func awsRestxml_deserializeOpHttpBindingsHeadObjectOutput(v *HeadObjectOutput, response *smithyhttp.Response) error { 6574 if v == nil { 6575 return fmt.Errorf("unsupported deserialization for nil %T", v) 6576 } 6577 6578 if headerValues := response.Header.Values("accept-ranges"); len(headerValues) != 0 { 6579 headerValues[0] = strings.TrimSpace(headerValues[0]) 6580 v.AcceptRanges = ptr.String(headerValues[0]) 6581 } 6582 6583 if headerValues := response.Header.Values("x-amz-archive-status"); len(headerValues) != 0 { 6584 headerValues[0] = strings.TrimSpace(headerValues[0]) 6585 v.ArchiveStatus = types.ArchiveStatus(headerValues[0]) 6586 } 6587 6588 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 6589 headerValues[0] = strings.TrimSpace(headerValues[0]) 6590 vv, err := strconv.ParseBool(headerValues[0]) 6591 if err != nil { 6592 return err 6593 } 6594 v.BucketKeyEnabled = vv 6595 } 6596 6597 if headerValues := response.Header.Values("Cache-Control"); len(headerValues) != 0 { 6598 headerValues[0] = strings.TrimSpace(headerValues[0]) 6599 v.CacheControl = ptr.String(headerValues[0]) 6600 } 6601 6602 if headerValues := response.Header.Values("Content-Disposition"); len(headerValues) != 0 { 6603 headerValues[0] = strings.TrimSpace(headerValues[0]) 6604 v.ContentDisposition = ptr.String(headerValues[0]) 6605 } 6606 6607 if headerValues := response.Header.Values("Content-Encoding"); len(headerValues) != 0 { 6608 headerValues[0] = strings.TrimSpace(headerValues[0]) 6609 v.ContentEncoding = ptr.String(headerValues[0]) 6610 } 6611 6612 if headerValues := response.Header.Values("Content-Language"); len(headerValues) != 0 { 6613 headerValues[0] = strings.TrimSpace(headerValues[0]) 6614 v.ContentLanguage = ptr.String(headerValues[0]) 6615 } 6616 6617 if headerValues := response.Header.Values("Content-Length"); len(headerValues) != 0 { 6618 headerValues[0] = strings.TrimSpace(headerValues[0]) 6619 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 6620 if err != nil { 6621 return err 6622 } 6623 v.ContentLength = vv 6624 } 6625 6626 if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { 6627 headerValues[0] = strings.TrimSpace(headerValues[0]) 6628 v.ContentType = ptr.String(headerValues[0]) 6629 } 6630 6631 if headerValues := response.Header.Values("x-amz-delete-marker"); len(headerValues) != 0 { 6632 headerValues[0] = strings.TrimSpace(headerValues[0]) 6633 vv, err := strconv.ParseBool(headerValues[0]) 6634 if err != nil { 6635 return err 6636 } 6637 v.DeleteMarker = vv 6638 } 6639 6640 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 6641 headerValues[0] = strings.TrimSpace(headerValues[0]) 6642 v.ETag = ptr.String(headerValues[0]) 6643 } 6644 6645 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 6646 headerValues[0] = strings.TrimSpace(headerValues[0]) 6647 v.Expiration = ptr.String(headerValues[0]) 6648 } 6649 6650 if headerValues := response.Header.Values("Expires"); len(headerValues) != 0 { 6651 headerValues[0] = strings.TrimSpace(headerValues[0]) 6652 t, err := smithytime.ParseHTTPDate(headerValues[0]) 6653 if err != nil { 6654 return err 6655 } 6656 v.Expires = ptr.Time(t) 6657 } 6658 6659 if headerValues := response.Header.Values("Last-Modified"); len(headerValues) != 0 { 6660 headerValues[0] = strings.TrimSpace(headerValues[0]) 6661 t, err := smithytime.ParseHTTPDate(headerValues[0]) 6662 if err != nil { 6663 return err 6664 } 6665 v.LastModified = ptr.Time(t) 6666 } 6667 6668 for headerKey, headerValues := range response.Header { 6669 if lenPrefix := len("x-amz-meta-"); len(headerKey) >= lenPrefix && strings.EqualFold(headerKey[:lenPrefix], "x-amz-meta-") { 6670 if v.Metadata == nil { 6671 v.Metadata = map[string]string{} 6672 } 6673 headerValues[0] = strings.TrimSpace(headerValues[0]) 6674 v.Metadata[strings.ToLower(headerKey[lenPrefix:])] = headerValues[0] 6675 } 6676 } 6677 6678 if headerValues := response.Header.Values("x-amz-missing-meta"); len(headerValues) != 0 { 6679 headerValues[0] = strings.TrimSpace(headerValues[0]) 6680 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 6681 if err != nil { 6682 return err 6683 } 6684 v.MissingMeta = int32(vv) 6685 } 6686 6687 if headerValues := response.Header.Values("x-amz-object-lock-legal-hold"); len(headerValues) != 0 { 6688 headerValues[0] = strings.TrimSpace(headerValues[0]) 6689 v.ObjectLockLegalHoldStatus = types.ObjectLockLegalHoldStatus(headerValues[0]) 6690 } 6691 6692 if headerValues := response.Header.Values("x-amz-object-lock-mode"); len(headerValues) != 0 { 6693 headerValues[0] = strings.TrimSpace(headerValues[0]) 6694 v.ObjectLockMode = types.ObjectLockMode(headerValues[0]) 6695 } 6696 6697 if headerValues := response.Header.Values("x-amz-object-lock-retain-until-date"); len(headerValues) != 0 { 6698 headerValues[0] = strings.TrimSpace(headerValues[0]) 6699 t, err := smithytime.ParseDateTime(headerValues[0]) 6700 if err != nil { 6701 return err 6702 } 6703 v.ObjectLockRetainUntilDate = ptr.Time(t) 6704 } 6705 6706 if headerValues := response.Header.Values("x-amz-mp-parts-count"); len(headerValues) != 0 { 6707 headerValues[0] = strings.TrimSpace(headerValues[0]) 6708 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 6709 if err != nil { 6710 return err 6711 } 6712 v.PartsCount = int32(vv) 6713 } 6714 6715 if headerValues := response.Header.Values("x-amz-replication-status"); len(headerValues) != 0 { 6716 headerValues[0] = strings.TrimSpace(headerValues[0]) 6717 v.ReplicationStatus = types.ReplicationStatus(headerValues[0]) 6718 } 6719 6720 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 6721 headerValues[0] = strings.TrimSpace(headerValues[0]) 6722 v.RequestCharged = types.RequestCharged(headerValues[0]) 6723 } 6724 6725 if headerValues := response.Header.Values("x-amz-restore"); len(headerValues) != 0 { 6726 headerValues[0] = strings.TrimSpace(headerValues[0]) 6727 v.Restore = ptr.String(headerValues[0]) 6728 } 6729 6730 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 6731 headerValues[0] = strings.TrimSpace(headerValues[0]) 6732 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 6733 } 6734 6735 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 6736 headerValues[0] = strings.TrimSpace(headerValues[0]) 6737 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 6738 } 6739 6740 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 6741 headerValues[0] = strings.TrimSpace(headerValues[0]) 6742 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 6743 } 6744 6745 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 6746 headerValues[0] = strings.TrimSpace(headerValues[0]) 6747 v.SSEKMSKeyId = ptr.String(headerValues[0]) 6748 } 6749 6750 if headerValues := response.Header.Values("x-amz-storage-class"); len(headerValues) != 0 { 6751 headerValues[0] = strings.TrimSpace(headerValues[0]) 6752 v.StorageClass = types.StorageClass(headerValues[0]) 6753 } 6754 6755 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 6756 headerValues[0] = strings.TrimSpace(headerValues[0]) 6757 v.VersionId = ptr.String(headerValues[0]) 6758 } 6759 6760 if headerValues := response.Header.Values("x-amz-website-redirect-location"); len(headerValues) != 0 { 6761 headerValues[0] = strings.TrimSpace(headerValues[0]) 6762 v.WebsiteRedirectLocation = ptr.String(headerValues[0]) 6763 } 6764 6765 return nil 6766} 6767 6768type awsRestxml_deserializeOpListBucketAnalyticsConfigurations struct { 6769} 6770 6771func (*awsRestxml_deserializeOpListBucketAnalyticsConfigurations) ID() string { 6772 return "OperationDeserializer" 6773} 6774 6775func (m *awsRestxml_deserializeOpListBucketAnalyticsConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6776 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6777) { 6778 out, metadata, err = next.HandleDeserialize(ctx, in) 6779 if err != nil { 6780 return out, metadata, err 6781 } 6782 6783 response, ok := out.RawResponse.(*smithyhttp.Response) 6784 if !ok { 6785 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6786 } 6787 6788 if response.StatusCode < 200 || response.StatusCode >= 300 { 6789 return out, metadata, awsRestxml_deserializeOpErrorListBucketAnalyticsConfigurations(response, &metadata) 6790 } 6791 output := &ListBucketAnalyticsConfigurationsOutput{} 6792 out.Result = output 6793 6794 var buff [1024]byte 6795 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6796 body := io.TeeReader(response.Body, ringBuffer) 6797 rootDecoder := xml.NewDecoder(body) 6798 t, err := smithyxml.FetchRootElement(rootDecoder) 6799 if err == io.EOF { 6800 return out, metadata, nil 6801 } 6802 if err != nil { 6803 var snapshot bytes.Buffer 6804 io.Copy(&snapshot, ringBuffer) 6805 return out, metadata, &smithy.DeserializationError{ 6806 Err: fmt.Errorf("failed to decode response body, %w", err), 6807 Snapshot: snapshot.Bytes(), 6808 } 6809 } 6810 6811 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6812 err = awsRestxml_deserializeOpDocumentListBucketAnalyticsConfigurationsOutput(&output, decoder) 6813 if err != nil { 6814 var snapshot bytes.Buffer 6815 io.Copy(&snapshot, ringBuffer) 6816 return out, metadata, &smithy.DeserializationError{ 6817 Err: fmt.Errorf("failed to decode response body, %w", err), 6818 Snapshot: snapshot.Bytes(), 6819 } 6820 } 6821 6822 return out, metadata, err 6823} 6824 6825func awsRestxml_deserializeOpErrorListBucketAnalyticsConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6826 var errorBuffer bytes.Buffer 6827 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6828 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6829 } 6830 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6831 6832 errorCode := "UnknownError" 6833 errorMessage := errorCode 6834 6835 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6836 UseStatusCode: true, StatusCode: response.StatusCode, 6837 }) 6838 if err != nil { 6839 return err 6840 } 6841 if hostID := errorComponents.HostID; len(hostID) != 0 { 6842 s3shared.SetHostIDMetadata(metadata, hostID) 6843 } 6844 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6845 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6846 } 6847 if len(errorComponents.Code) != 0 { 6848 errorCode = errorComponents.Code 6849 } 6850 if len(errorComponents.Message) != 0 { 6851 errorMessage = errorComponents.Message 6852 } 6853 errorBody.Seek(0, io.SeekStart) 6854 switch { 6855 default: 6856 genericError := &smithy.GenericAPIError{ 6857 Code: errorCode, 6858 Message: errorMessage, 6859 } 6860 return genericError 6861 6862 } 6863} 6864 6865func awsRestxml_deserializeOpDocumentListBucketAnalyticsConfigurationsOutput(v **ListBucketAnalyticsConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 6866 if v == nil { 6867 return fmt.Errorf("unexpected nil of type %T", v) 6868 } 6869 var sv *ListBucketAnalyticsConfigurationsOutput 6870 if *v == nil { 6871 sv = &ListBucketAnalyticsConfigurationsOutput{} 6872 } else { 6873 sv = *v 6874 } 6875 6876 for { 6877 t, done, err := decoder.Token() 6878 if err != nil { 6879 return err 6880 } 6881 if done { 6882 break 6883 } 6884 originalDecoder := decoder 6885 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6886 switch { 6887 case strings.EqualFold("AnalyticsConfiguration", t.Name.Local): 6888 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6889 if err := awsRestxml_deserializeDocumentAnalyticsConfigurationListUnwrapped(&sv.AnalyticsConfigurationList, nodeDecoder); err != nil { 6890 return err 6891 } 6892 6893 case strings.EqualFold("ContinuationToken", t.Name.Local): 6894 val, err := decoder.Value() 6895 if err != nil { 6896 return err 6897 } 6898 if val == nil { 6899 break 6900 } 6901 { 6902 xtv := string(val) 6903 sv.ContinuationToken = ptr.String(xtv) 6904 } 6905 6906 case strings.EqualFold("IsTruncated", t.Name.Local): 6907 val, err := decoder.Value() 6908 if err != nil { 6909 return err 6910 } 6911 if val == nil { 6912 break 6913 } 6914 { 6915 xtv, err := strconv.ParseBool(string(val)) 6916 if err != nil { 6917 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 6918 } 6919 sv.IsTruncated = xtv 6920 } 6921 6922 case strings.EqualFold("NextContinuationToken", t.Name.Local): 6923 val, err := decoder.Value() 6924 if err != nil { 6925 return err 6926 } 6927 if val == nil { 6928 break 6929 } 6930 { 6931 xtv := string(val) 6932 sv.NextContinuationToken = ptr.String(xtv) 6933 } 6934 6935 default: 6936 // Do nothing and ignore the unexpected tag element 6937 err = decoder.Decoder.Skip() 6938 if err != nil { 6939 return err 6940 } 6941 6942 } 6943 decoder = originalDecoder 6944 } 6945 *v = sv 6946 return nil 6947} 6948 6949type awsRestxml_deserializeOpListBucketIntelligentTieringConfigurations struct { 6950} 6951 6952func (*awsRestxml_deserializeOpListBucketIntelligentTieringConfigurations) ID() string { 6953 return "OperationDeserializer" 6954} 6955 6956func (m *awsRestxml_deserializeOpListBucketIntelligentTieringConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6957 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6958) { 6959 out, metadata, err = next.HandleDeserialize(ctx, in) 6960 if err != nil { 6961 return out, metadata, err 6962 } 6963 6964 response, ok := out.RawResponse.(*smithyhttp.Response) 6965 if !ok { 6966 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6967 } 6968 6969 if response.StatusCode < 200 || response.StatusCode >= 300 { 6970 return out, metadata, awsRestxml_deserializeOpErrorListBucketIntelligentTieringConfigurations(response, &metadata) 6971 } 6972 output := &ListBucketIntelligentTieringConfigurationsOutput{} 6973 out.Result = output 6974 6975 var buff [1024]byte 6976 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6977 body := io.TeeReader(response.Body, ringBuffer) 6978 rootDecoder := xml.NewDecoder(body) 6979 t, err := smithyxml.FetchRootElement(rootDecoder) 6980 if err == io.EOF { 6981 return out, metadata, nil 6982 } 6983 if err != nil { 6984 var snapshot bytes.Buffer 6985 io.Copy(&snapshot, ringBuffer) 6986 return out, metadata, &smithy.DeserializationError{ 6987 Err: fmt.Errorf("failed to decode response body, %w", err), 6988 Snapshot: snapshot.Bytes(), 6989 } 6990 } 6991 6992 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6993 err = awsRestxml_deserializeOpDocumentListBucketIntelligentTieringConfigurationsOutput(&output, decoder) 6994 if err != nil { 6995 var snapshot bytes.Buffer 6996 io.Copy(&snapshot, ringBuffer) 6997 return out, metadata, &smithy.DeserializationError{ 6998 Err: fmt.Errorf("failed to decode response body, %w", err), 6999 Snapshot: snapshot.Bytes(), 7000 } 7001 } 7002 7003 return out, metadata, err 7004} 7005 7006func awsRestxml_deserializeOpErrorListBucketIntelligentTieringConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7007 var errorBuffer bytes.Buffer 7008 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7009 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7010 } 7011 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7012 7013 errorCode := "UnknownError" 7014 errorMessage := errorCode 7015 7016 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7017 UseStatusCode: true, StatusCode: response.StatusCode, 7018 }) 7019 if err != nil { 7020 return err 7021 } 7022 if hostID := errorComponents.HostID; len(hostID) != 0 { 7023 s3shared.SetHostIDMetadata(metadata, hostID) 7024 } 7025 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7026 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7027 } 7028 if len(errorComponents.Code) != 0 { 7029 errorCode = errorComponents.Code 7030 } 7031 if len(errorComponents.Message) != 0 { 7032 errorMessage = errorComponents.Message 7033 } 7034 errorBody.Seek(0, io.SeekStart) 7035 switch { 7036 default: 7037 genericError := &smithy.GenericAPIError{ 7038 Code: errorCode, 7039 Message: errorMessage, 7040 } 7041 return genericError 7042 7043 } 7044} 7045 7046func awsRestxml_deserializeOpDocumentListBucketIntelligentTieringConfigurationsOutput(v **ListBucketIntelligentTieringConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 7047 if v == nil { 7048 return fmt.Errorf("unexpected nil of type %T", v) 7049 } 7050 var sv *ListBucketIntelligentTieringConfigurationsOutput 7051 if *v == nil { 7052 sv = &ListBucketIntelligentTieringConfigurationsOutput{} 7053 } else { 7054 sv = *v 7055 } 7056 7057 for { 7058 t, done, err := decoder.Token() 7059 if err != nil { 7060 return err 7061 } 7062 if done { 7063 break 7064 } 7065 originalDecoder := decoder 7066 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7067 switch { 7068 case strings.EqualFold("ContinuationToken", t.Name.Local): 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 sv.ContinuationToken = ptr.String(xtv) 7079 } 7080 7081 case strings.EqualFold("IntelligentTieringConfiguration", t.Name.Local): 7082 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7083 if err := awsRestxml_deserializeDocumentIntelligentTieringConfigurationListUnwrapped(&sv.IntelligentTieringConfigurationList, nodeDecoder); err != nil { 7084 return err 7085 } 7086 7087 case strings.EqualFold("IsTruncated", t.Name.Local): 7088 val, err := decoder.Value() 7089 if err != nil { 7090 return err 7091 } 7092 if val == nil { 7093 break 7094 } 7095 { 7096 xtv, err := strconv.ParseBool(string(val)) 7097 if err != nil { 7098 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7099 } 7100 sv.IsTruncated = xtv 7101 } 7102 7103 case strings.EqualFold("NextContinuationToken", t.Name.Local): 7104 val, err := decoder.Value() 7105 if err != nil { 7106 return err 7107 } 7108 if val == nil { 7109 break 7110 } 7111 { 7112 xtv := string(val) 7113 sv.NextContinuationToken = ptr.String(xtv) 7114 } 7115 7116 default: 7117 // Do nothing and ignore the unexpected tag element 7118 err = decoder.Decoder.Skip() 7119 if err != nil { 7120 return err 7121 } 7122 7123 } 7124 decoder = originalDecoder 7125 } 7126 *v = sv 7127 return nil 7128} 7129 7130type awsRestxml_deserializeOpListBucketInventoryConfigurations struct { 7131} 7132 7133func (*awsRestxml_deserializeOpListBucketInventoryConfigurations) ID() string { 7134 return "OperationDeserializer" 7135} 7136 7137func (m *awsRestxml_deserializeOpListBucketInventoryConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7138 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7139) { 7140 out, metadata, err = next.HandleDeserialize(ctx, in) 7141 if err != nil { 7142 return out, metadata, err 7143 } 7144 7145 response, ok := out.RawResponse.(*smithyhttp.Response) 7146 if !ok { 7147 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7148 } 7149 7150 if response.StatusCode < 200 || response.StatusCode >= 300 { 7151 return out, metadata, awsRestxml_deserializeOpErrorListBucketInventoryConfigurations(response, &metadata) 7152 } 7153 output := &ListBucketInventoryConfigurationsOutput{} 7154 out.Result = output 7155 7156 var buff [1024]byte 7157 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7158 body := io.TeeReader(response.Body, ringBuffer) 7159 rootDecoder := xml.NewDecoder(body) 7160 t, err := smithyxml.FetchRootElement(rootDecoder) 7161 if err == io.EOF { 7162 return out, metadata, nil 7163 } 7164 if err != nil { 7165 var snapshot bytes.Buffer 7166 io.Copy(&snapshot, ringBuffer) 7167 return out, metadata, &smithy.DeserializationError{ 7168 Err: fmt.Errorf("failed to decode response body, %w", err), 7169 Snapshot: snapshot.Bytes(), 7170 } 7171 } 7172 7173 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7174 err = awsRestxml_deserializeOpDocumentListBucketInventoryConfigurationsOutput(&output, decoder) 7175 if err != nil { 7176 var snapshot bytes.Buffer 7177 io.Copy(&snapshot, ringBuffer) 7178 return out, metadata, &smithy.DeserializationError{ 7179 Err: fmt.Errorf("failed to decode response body, %w", err), 7180 Snapshot: snapshot.Bytes(), 7181 } 7182 } 7183 7184 return out, metadata, err 7185} 7186 7187func awsRestxml_deserializeOpErrorListBucketInventoryConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7188 var errorBuffer bytes.Buffer 7189 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7190 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7191 } 7192 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7193 7194 errorCode := "UnknownError" 7195 errorMessage := errorCode 7196 7197 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7198 UseStatusCode: true, StatusCode: response.StatusCode, 7199 }) 7200 if err != nil { 7201 return err 7202 } 7203 if hostID := errorComponents.HostID; len(hostID) != 0 { 7204 s3shared.SetHostIDMetadata(metadata, hostID) 7205 } 7206 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7207 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7208 } 7209 if len(errorComponents.Code) != 0 { 7210 errorCode = errorComponents.Code 7211 } 7212 if len(errorComponents.Message) != 0 { 7213 errorMessage = errorComponents.Message 7214 } 7215 errorBody.Seek(0, io.SeekStart) 7216 switch { 7217 default: 7218 genericError := &smithy.GenericAPIError{ 7219 Code: errorCode, 7220 Message: errorMessage, 7221 } 7222 return genericError 7223 7224 } 7225} 7226 7227func awsRestxml_deserializeOpDocumentListBucketInventoryConfigurationsOutput(v **ListBucketInventoryConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 7228 if v == nil { 7229 return fmt.Errorf("unexpected nil of type %T", v) 7230 } 7231 var sv *ListBucketInventoryConfigurationsOutput 7232 if *v == nil { 7233 sv = &ListBucketInventoryConfigurationsOutput{} 7234 } else { 7235 sv = *v 7236 } 7237 7238 for { 7239 t, done, err := decoder.Token() 7240 if err != nil { 7241 return err 7242 } 7243 if done { 7244 break 7245 } 7246 originalDecoder := decoder 7247 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7248 switch { 7249 case strings.EqualFold("ContinuationToken", t.Name.Local): 7250 val, err := decoder.Value() 7251 if err != nil { 7252 return err 7253 } 7254 if val == nil { 7255 break 7256 } 7257 { 7258 xtv := string(val) 7259 sv.ContinuationToken = ptr.String(xtv) 7260 } 7261 7262 case strings.EqualFold("InventoryConfiguration", t.Name.Local): 7263 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7264 if err := awsRestxml_deserializeDocumentInventoryConfigurationListUnwrapped(&sv.InventoryConfigurationList, nodeDecoder); err != nil { 7265 return err 7266 } 7267 7268 case strings.EqualFold("IsTruncated", t.Name.Local): 7269 val, err := decoder.Value() 7270 if err != nil { 7271 return err 7272 } 7273 if val == nil { 7274 break 7275 } 7276 { 7277 xtv, err := strconv.ParseBool(string(val)) 7278 if err != nil { 7279 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7280 } 7281 sv.IsTruncated = xtv 7282 } 7283 7284 case strings.EqualFold("NextContinuationToken", t.Name.Local): 7285 val, err := decoder.Value() 7286 if err != nil { 7287 return err 7288 } 7289 if val == nil { 7290 break 7291 } 7292 { 7293 xtv := string(val) 7294 sv.NextContinuationToken = ptr.String(xtv) 7295 } 7296 7297 default: 7298 // Do nothing and ignore the unexpected tag element 7299 err = decoder.Decoder.Skip() 7300 if err != nil { 7301 return err 7302 } 7303 7304 } 7305 decoder = originalDecoder 7306 } 7307 *v = sv 7308 return nil 7309} 7310 7311type awsRestxml_deserializeOpListBucketMetricsConfigurations struct { 7312} 7313 7314func (*awsRestxml_deserializeOpListBucketMetricsConfigurations) ID() string { 7315 return "OperationDeserializer" 7316} 7317 7318func (m *awsRestxml_deserializeOpListBucketMetricsConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7319 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7320) { 7321 out, metadata, err = next.HandleDeserialize(ctx, in) 7322 if err != nil { 7323 return out, metadata, err 7324 } 7325 7326 response, ok := out.RawResponse.(*smithyhttp.Response) 7327 if !ok { 7328 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7329 } 7330 7331 if response.StatusCode < 200 || response.StatusCode >= 300 { 7332 return out, metadata, awsRestxml_deserializeOpErrorListBucketMetricsConfigurations(response, &metadata) 7333 } 7334 output := &ListBucketMetricsConfigurationsOutput{} 7335 out.Result = output 7336 7337 var buff [1024]byte 7338 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7339 body := io.TeeReader(response.Body, ringBuffer) 7340 rootDecoder := xml.NewDecoder(body) 7341 t, err := smithyxml.FetchRootElement(rootDecoder) 7342 if err == io.EOF { 7343 return out, metadata, nil 7344 } 7345 if err != nil { 7346 var snapshot bytes.Buffer 7347 io.Copy(&snapshot, ringBuffer) 7348 return out, metadata, &smithy.DeserializationError{ 7349 Err: fmt.Errorf("failed to decode response body, %w", err), 7350 Snapshot: snapshot.Bytes(), 7351 } 7352 } 7353 7354 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7355 err = awsRestxml_deserializeOpDocumentListBucketMetricsConfigurationsOutput(&output, decoder) 7356 if err != nil { 7357 var snapshot bytes.Buffer 7358 io.Copy(&snapshot, ringBuffer) 7359 return out, metadata, &smithy.DeserializationError{ 7360 Err: fmt.Errorf("failed to decode response body, %w", err), 7361 Snapshot: snapshot.Bytes(), 7362 } 7363 } 7364 7365 return out, metadata, err 7366} 7367 7368func awsRestxml_deserializeOpErrorListBucketMetricsConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7369 var errorBuffer bytes.Buffer 7370 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7371 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7372 } 7373 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7374 7375 errorCode := "UnknownError" 7376 errorMessage := errorCode 7377 7378 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7379 UseStatusCode: true, StatusCode: response.StatusCode, 7380 }) 7381 if err != nil { 7382 return err 7383 } 7384 if hostID := errorComponents.HostID; len(hostID) != 0 { 7385 s3shared.SetHostIDMetadata(metadata, hostID) 7386 } 7387 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7388 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7389 } 7390 if len(errorComponents.Code) != 0 { 7391 errorCode = errorComponents.Code 7392 } 7393 if len(errorComponents.Message) != 0 { 7394 errorMessage = errorComponents.Message 7395 } 7396 errorBody.Seek(0, io.SeekStart) 7397 switch { 7398 default: 7399 genericError := &smithy.GenericAPIError{ 7400 Code: errorCode, 7401 Message: errorMessage, 7402 } 7403 return genericError 7404 7405 } 7406} 7407 7408func awsRestxml_deserializeOpDocumentListBucketMetricsConfigurationsOutput(v **ListBucketMetricsConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 7409 if v == nil { 7410 return fmt.Errorf("unexpected nil of type %T", v) 7411 } 7412 var sv *ListBucketMetricsConfigurationsOutput 7413 if *v == nil { 7414 sv = &ListBucketMetricsConfigurationsOutput{} 7415 } else { 7416 sv = *v 7417 } 7418 7419 for { 7420 t, done, err := decoder.Token() 7421 if err != nil { 7422 return err 7423 } 7424 if done { 7425 break 7426 } 7427 originalDecoder := decoder 7428 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7429 switch { 7430 case strings.EqualFold("ContinuationToken", t.Name.Local): 7431 val, err := decoder.Value() 7432 if err != nil { 7433 return err 7434 } 7435 if val == nil { 7436 break 7437 } 7438 { 7439 xtv := string(val) 7440 sv.ContinuationToken = ptr.String(xtv) 7441 } 7442 7443 case strings.EqualFold("IsTruncated", t.Name.Local): 7444 val, err := decoder.Value() 7445 if err != nil { 7446 return err 7447 } 7448 if val == nil { 7449 break 7450 } 7451 { 7452 xtv, err := strconv.ParseBool(string(val)) 7453 if err != nil { 7454 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7455 } 7456 sv.IsTruncated = xtv 7457 } 7458 7459 case strings.EqualFold("MetricsConfiguration", t.Name.Local): 7460 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7461 if err := awsRestxml_deserializeDocumentMetricsConfigurationListUnwrapped(&sv.MetricsConfigurationList, nodeDecoder); err != nil { 7462 return err 7463 } 7464 7465 case strings.EqualFold("NextContinuationToken", t.Name.Local): 7466 val, err := decoder.Value() 7467 if err != nil { 7468 return err 7469 } 7470 if val == nil { 7471 break 7472 } 7473 { 7474 xtv := string(val) 7475 sv.NextContinuationToken = ptr.String(xtv) 7476 } 7477 7478 default: 7479 // Do nothing and ignore the unexpected tag element 7480 err = decoder.Decoder.Skip() 7481 if err != nil { 7482 return err 7483 } 7484 7485 } 7486 decoder = originalDecoder 7487 } 7488 *v = sv 7489 return nil 7490} 7491 7492type awsRestxml_deserializeOpListBuckets struct { 7493} 7494 7495func (*awsRestxml_deserializeOpListBuckets) ID() string { 7496 return "OperationDeserializer" 7497} 7498 7499func (m *awsRestxml_deserializeOpListBuckets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7500 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7501) { 7502 out, metadata, err = next.HandleDeserialize(ctx, in) 7503 if err != nil { 7504 return out, metadata, err 7505 } 7506 7507 response, ok := out.RawResponse.(*smithyhttp.Response) 7508 if !ok { 7509 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7510 } 7511 7512 if response.StatusCode < 200 || response.StatusCode >= 300 { 7513 return out, metadata, awsRestxml_deserializeOpErrorListBuckets(response, &metadata) 7514 } 7515 output := &ListBucketsOutput{} 7516 out.Result = output 7517 7518 var buff [1024]byte 7519 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7520 body := io.TeeReader(response.Body, ringBuffer) 7521 rootDecoder := xml.NewDecoder(body) 7522 t, err := smithyxml.FetchRootElement(rootDecoder) 7523 if err == io.EOF { 7524 return out, metadata, nil 7525 } 7526 if err != nil { 7527 var snapshot bytes.Buffer 7528 io.Copy(&snapshot, ringBuffer) 7529 return out, metadata, &smithy.DeserializationError{ 7530 Err: fmt.Errorf("failed to decode response body, %w", err), 7531 Snapshot: snapshot.Bytes(), 7532 } 7533 } 7534 7535 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7536 err = awsRestxml_deserializeOpDocumentListBucketsOutput(&output, decoder) 7537 if err != nil { 7538 var snapshot bytes.Buffer 7539 io.Copy(&snapshot, ringBuffer) 7540 return out, metadata, &smithy.DeserializationError{ 7541 Err: fmt.Errorf("failed to decode response body, %w", err), 7542 Snapshot: snapshot.Bytes(), 7543 } 7544 } 7545 7546 return out, metadata, err 7547} 7548 7549func awsRestxml_deserializeOpErrorListBuckets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7550 var errorBuffer bytes.Buffer 7551 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7552 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7553 } 7554 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7555 7556 errorCode := "UnknownError" 7557 errorMessage := errorCode 7558 7559 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7560 UseStatusCode: true, StatusCode: response.StatusCode, 7561 }) 7562 if err != nil { 7563 return err 7564 } 7565 if hostID := errorComponents.HostID; len(hostID) != 0 { 7566 s3shared.SetHostIDMetadata(metadata, hostID) 7567 } 7568 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7569 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7570 } 7571 if len(errorComponents.Code) != 0 { 7572 errorCode = errorComponents.Code 7573 } 7574 if len(errorComponents.Message) != 0 { 7575 errorMessage = errorComponents.Message 7576 } 7577 errorBody.Seek(0, io.SeekStart) 7578 switch { 7579 default: 7580 genericError := &smithy.GenericAPIError{ 7581 Code: errorCode, 7582 Message: errorMessage, 7583 } 7584 return genericError 7585 7586 } 7587} 7588 7589func awsRestxml_deserializeOpDocumentListBucketsOutput(v **ListBucketsOutput, decoder smithyxml.NodeDecoder) error { 7590 if v == nil { 7591 return fmt.Errorf("unexpected nil of type %T", v) 7592 } 7593 var sv *ListBucketsOutput 7594 if *v == nil { 7595 sv = &ListBucketsOutput{} 7596 } else { 7597 sv = *v 7598 } 7599 7600 for { 7601 t, done, err := decoder.Token() 7602 if err != nil { 7603 return err 7604 } 7605 if done { 7606 break 7607 } 7608 originalDecoder := decoder 7609 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7610 switch { 7611 case strings.EqualFold("Buckets", t.Name.Local): 7612 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7613 if err := awsRestxml_deserializeDocumentBuckets(&sv.Buckets, nodeDecoder); err != nil { 7614 return err 7615 } 7616 7617 case strings.EqualFold("Owner", t.Name.Local): 7618 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7619 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 7620 return err 7621 } 7622 7623 default: 7624 // Do nothing and ignore the unexpected tag element 7625 err = decoder.Decoder.Skip() 7626 if err != nil { 7627 return err 7628 } 7629 7630 } 7631 decoder = originalDecoder 7632 } 7633 *v = sv 7634 return nil 7635} 7636 7637type awsRestxml_deserializeOpListMultipartUploads struct { 7638} 7639 7640func (*awsRestxml_deserializeOpListMultipartUploads) ID() string { 7641 return "OperationDeserializer" 7642} 7643 7644func (m *awsRestxml_deserializeOpListMultipartUploads) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7645 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7646) { 7647 out, metadata, err = next.HandleDeserialize(ctx, in) 7648 if err != nil { 7649 return out, metadata, err 7650 } 7651 7652 response, ok := out.RawResponse.(*smithyhttp.Response) 7653 if !ok { 7654 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7655 } 7656 7657 if response.StatusCode < 200 || response.StatusCode >= 300 { 7658 return out, metadata, awsRestxml_deserializeOpErrorListMultipartUploads(response, &metadata) 7659 } 7660 output := &ListMultipartUploadsOutput{} 7661 out.Result = output 7662 7663 var buff [1024]byte 7664 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7665 body := io.TeeReader(response.Body, ringBuffer) 7666 rootDecoder := xml.NewDecoder(body) 7667 t, err := smithyxml.FetchRootElement(rootDecoder) 7668 if err == io.EOF { 7669 return out, metadata, nil 7670 } 7671 if err != nil { 7672 var snapshot bytes.Buffer 7673 io.Copy(&snapshot, ringBuffer) 7674 return out, metadata, &smithy.DeserializationError{ 7675 Err: fmt.Errorf("failed to decode response body, %w", err), 7676 Snapshot: snapshot.Bytes(), 7677 } 7678 } 7679 7680 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7681 err = awsRestxml_deserializeOpDocumentListMultipartUploadsOutput(&output, decoder) 7682 if err != nil { 7683 var snapshot bytes.Buffer 7684 io.Copy(&snapshot, ringBuffer) 7685 return out, metadata, &smithy.DeserializationError{ 7686 Err: fmt.Errorf("failed to decode response body, %w", err), 7687 Snapshot: snapshot.Bytes(), 7688 } 7689 } 7690 7691 return out, metadata, err 7692} 7693 7694func awsRestxml_deserializeOpErrorListMultipartUploads(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7695 var errorBuffer bytes.Buffer 7696 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7697 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7698 } 7699 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7700 7701 errorCode := "UnknownError" 7702 errorMessage := errorCode 7703 7704 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7705 UseStatusCode: true, StatusCode: response.StatusCode, 7706 }) 7707 if err != nil { 7708 return err 7709 } 7710 if hostID := errorComponents.HostID; len(hostID) != 0 { 7711 s3shared.SetHostIDMetadata(metadata, hostID) 7712 } 7713 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7714 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7715 } 7716 if len(errorComponents.Code) != 0 { 7717 errorCode = errorComponents.Code 7718 } 7719 if len(errorComponents.Message) != 0 { 7720 errorMessage = errorComponents.Message 7721 } 7722 errorBody.Seek(0, io.SeekStart) 7723 switch { 7724 default: 7725 genericError := &smithy.GenericAPIError{ 7726 Code: errorCode, 7727 Message: errorMessage, 7728 } 7729 return genericError 7730 7731 } 7732} 7733 7734func awsRestxml_deserializeOpDocumentListMultipartUploadsOutput(v **ListMultipartUploadsOutput, decoder smithyxml.NodeDecoder) error { 7735 if v == nil { 7736 return fmt.Errorf("unexpected nil of type %T", v) 7737 } 7738 var sv *ListMultipartUploadsOutput 7739 if *v == nil { 7740 sv = &ListMultipartUploadsOutput{} 7741 } else { 7742 sv = *v 7743 } 7744 7745 for { 7746 t, done, err := decoder.Token() 7747 if err != nil { 7748 return err 7749 } 7750 if done { 7751 break 7752 } 7753 originalDecoder := decoder 7754 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7755 switch { 7756 case strings.EqualFold("Bucket", t.Name.Local): 7757 val, err := decoder.Value() 7758 if err != nil { 7759 return err 7760 } 7761 if val == nil { 7762 break 7763 } 7764 { 7765 xtv := string(val) 7766 sv.Bucket = ptr.String(xtv) 7767 } 7768 7769 case strings.EqualFold("CommonPrefixes", t.Name.Local): 7770 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7771 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 7772 return err 7773 } 7774 7775 case strings.EqualFold("Delimiter", t.Name.Local): 7776 val, err := decoder.Value() 7777 if err != nil { 7778 return err 7779 } 7780 if val == nil { 7781 break 7782 } 7783 { 7784 xtv := string(val) 7785 sv.Delimiter = ptr.String(xtv) 7786 } 7787 7788 case strings.EqualFold("EncodingType", t.Name.Local): 7789 val, err := decoder.Value() 7790 if err != nil { 7791 return err 7792 } 7793 if val == nil { 7794 break 7795 } 7796 { 7797 xtv := string(val) 7798 sv.EncodingType = types.EncodingType(xtv) 7799 } 7800 7801 case strings.EqualFold("IsTruncated", t.Name.Local): 7802 val, err := decoder.Value() 7803 if err != nil { 7804 return err 7805 } 7806 if val == nil { 7807 break 7808 } 7809 { 7810 xtv, err := strconv.ParseBool(string(val)) 7811 if err != nil { 7812 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7813 } 7814 sv.IsTruncated = xtv 7815 } 7816 7817 case strings.EqualFold("KeyMarker", t.Name.Local): 7818 val, err := decoder.Value() 7819 if err != nil { 7820 return err 7821 } 7822 if val == nil { 7823 break 7824 } 7825 { 7826 xtv := string(val) 7827 sv.KeyMarker = ptr.String(xtv) 7828 } 7829 7830 case strings.EqualFold("MaxUploads", t.Name.Local): 7831 val, err := decoder.Value() 7832 if err != nil { 7833 return err 7834 } 7835 if val == nil { 7836 break 7837 } 7838 { 7839 xtv := string(val) 7840 i64, err := strconv.ParseInt(xtv, 10, 64) 7841 if err != nil { 7842 return err 7843 } 7844 sv.MaxUploads = int32(i64) 7845 } 7846 7847 case strings.EqualFold("NextKeyMarker", t.Name.Local): 7848 val, err := decoder.Value() 7849 if err != nil { 7850 return err 7851 } 7852 if val == nil { 7853 break 7854 } 7855 { 7856 xtv := string(val) 7857 sv.NextKeyMarker = ptr.String(xtv) 7858 } 7859 7860 case strings.EqualFold("NextUploadIdMarker", t.Name.Local): 7861 val, err := decoder.Value() 7862 if err != nil { 7863 return err 7864 } 7865 if val == nil { 7866 break 7867 } 7868 { 7869 xtv := string(val) 7870 sv.NextUploadIdMarker = ptr.String(xtv) 7871 } 7872 7873 case strings.EqualFold("Prefix", t.Name.Local): 7874 val, err := decoder.Value() 7875 if err != nil { 7876 return err 7877 } 7878 if val == nil { 7879 break 7880 } 7881 { 7882 xtv := string(val) 7883 sv.Prefix = ptr.String(xtv) 7884 } 7885 7886 case strings.EqualFold("UploadIdMarker", t.Name.Local): 7887 val, err := decoder.Value() 7888 if err != nil { 7889 return err 7890 } 7891 if val == nil { 7892 break 7893 } 7894 { 7895 xtv := string(val) 7896 sv.UploadIdMarker = ptr.String(xtv) 7897 } 7898 7899 case strings.EqualFold("Upload", t.Name.Local): 7900 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7901 if err := awsRestxml_deserializeDocumentMultipartUploadListUnwrapped(&sv.Uploads, nodeDecoder); err != nil { 7902 return err 7903 } 7904 7905 default: 7906 // Do nothing and ignore the unexpected tag element 7907 err = decoder.Decoder.Skip() 7908 if err != nil { 7909 return err 7910 } 7911 7912 } 7913 decoder = originalDecoder 7914 } 7915 *v = sv 7916 return nil 7917} 7918 7919type awsRestxml_deserializeOpListObjects struct { 7920} 7921 7922func (*awsRestxml_deserializeOpListObjects) ID() string { 7923 return "OperationDeserializer" 7924} 7925 7926func (m *awsRestxml_deserializeOpListObjects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7927 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7928) { 7929 out, metadata, err = next.HandleDeserialize(ctx, in) 7930 if err != nil { 7931 return out, metadata, err 7932 } 7933 7934 response, ok := out.RawResponse.(*smithyhttp.Response) 7935 if !ok { 7936 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7937 } 7938 7939 if response.StatusCode < 200 || response.StatusCode >= 300 { 7940 return out, metadata, awsRestxml_deserializeOpErrorListObjects(response, &metadata) 7941 } 7942 output := &ListObjectsOutput{} 7943 out.Result = output 7944 7945 var buff [1024]byte 7946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7947 body := io.TeeReader(response.Body, ringBuffer) 7948 rootDecoder := xml.NewDecoder(body) 7949 t, err := smithyxml.FetchRootElement(rootDecoder) 7950 if err == io.EOF { 7951 return out, metadata, nil 7952 } 7953 if err != nil { 7954 var snapshot bytes.Buffer 7955 io.Copy(&snapshot, ringBuffer) 7956 return out, metadata, &smithy.DeserializationError{ 7957 Err: fmt.Errorf("failed to decode response body, %w", err), 7958 Snapshot: snapshot.Bytes(), 7959 } 7960 } 7961 7962 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7963 err = awsRestxml_deserializeOpDocumentListObjectsOutput(&output, decoder) 7964 if err != nil { 7965 var snapshot bytes.Buffer 7966 io.Copy(&snapshot, ringBuffer) 7967 return out, metadata, &smithy.DeserializationError{ 7968 Err: fmt.Errorf("failed to decode response body, %w", err), 7969 Snapshot: snapshot.Bytes(), 7970 } 7971 } 7972 7973 return out, metadata, err 7974} 7975 7976func awsRestxml_deserializeOpErrorListObjects(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7977 var errorBuffer bytes.Buffer 7978 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7979 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7980 } 7981 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7982 7983 errorCode := "UnknownError" 7984 errorMessage := errorCode 7985 7986 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7987 UseStatusCode: true, StatusCode: response.StatusCode, 7988 }) 7989 if err != nil { 7990 return err 7991 } 7992 if hostID := errorComponents.HostID; len(hostID) != 0 { 7993 s3shared.SetHostIDMetadata(metadata, hostID) 7994 } 7995 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7996 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7997 } 7998 if len(errorComponents.Code) != 0 { 7999 errorCode = errorComponents.Code 8000 } 8001 if len(errorComponents.Message) != 0 { 8002 errorMessage = errorComponents.Message 8003 } 8004 errorBody.Seek(0, io.SeekStart) 8005 switch { 8006 case strings.EqualFold("NoSuchBucket", errorCode): 8007 return awsRestxml_deserializeErrorNoSuchBucket(response, errorBody) 8008 8009 default: 8010 genericError := &smithy.GenericAPIError{ 8011 Code: errorCode, 8012 Message: errorMessage, 8013 } 8014 return genericError 8015 8016 } 8017} 8018 8019func awsRestxml_deserializeOpDocumentListObjectsOutput(v **ListObjectsOutput, decoder smithyxml.NodeDecoder) error { 8020 if v == nil { 8021 return fmt.Errorf("unexpected nil of type %T", v) 8022 } 8023 var sv *ListObjectsOutput 8024 if *v == nil { 8025 sv = &ListObjectsOutput{} 8026 } else { 8027 sv = *v 8028 } 8029 8030 for { 8031 t, done, err := decoder.Token() 8032 if err != nil { 8033 return err 8034 } 8035 if done { 8036 break 8037 } 8038 originalDecoder := decoder 8039 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8040 switch { 8041 case strings.EqualFold("CommonPrefixes", t.Name.Local): 8042 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8043 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 8044 return err 8045 } 8046 8047 case strings.EqualFold("Contents", t.Name.Local): 8048 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8049 if err := awsRestxml_deserializeDocumentObjectListUnwrapped(&sv.Contents, nodeDecoder); err != nil { 8050 return err 8051 } 8052 8053 case strings.EqualFold("Delimiter", t.Name.Local): 8054 val, err := decoder.Value() 8055 if err != nil { 8056 return err 8057 } 8058 if val == nil { 8059 break 8060 } 8061 { 8062 xtv := string(val) 8063 sv.Delimiter = ptr.String(xtv) 8064 } 8065 8066 case strings.EqualFold("EncodingType", t.Name.Local): 8067 val, err := decoder.Value() 8068 if err != nil { 8069 return err 8070 } 8071 if val == nil { 8072 break 8073 } 8074 { 8075 xtv := string(val) 8076 sv.EncodingType = types.EncodingType(xtv) 8077 } 8078 8079 case strings.EqualFold("IsTruncated", t.Name.Local): 8080 val, err := decoder.Value() 8081 if err != nil { 8082 return err 8083 } 8084 if val == nil { 8085 break 8086 } 8087 { 8088 xtv, err := strconv.ParseBool(string(val)) 8089 if err != nil { 8090 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8091 } 8092 sv.IsTruncated = xtv 8093 } 8094 8095 case strings.EqualFold("Marker", t.Name.Local): 8096 val, err := decoder.Value() 8097 if err != nil { 8098 return err 8099 } 8100 if val == nil { 8101 break 8102 } 8103 { 8104 xtv := string(val) 8105 sv.Marker = ptr.String(xtv) 8106 } 8107 8108 case strings.EqualFold("MaxKeys", t.Name.Local): 8109 val, err := decoder.Value() 8110 if err != nil { 8111 return err 8112 } 8113 if val == nil { 8114 break 8115 } 8116 { 8117 xtv := string(val) 8118 i64, err := strconv.ParseInt(xtv, 10, 64) 8119 if err != nil { 8120 return err 8121 } 8122 sv.MaxKeys = int32(i64) 8123 } 8124 8125 case strings.EqualFold("Name", t.Name.Local): 8126 val, err := decoder.Value() 8127 if err != nil { 8128 return err 8129 } 8130 if val == nil { 8131 break 8132 } 8133 { 8134 xtv := string(val) 8135 sv.Name = ptr.String(xtv) 8136 } 8137 8138 case strings.EqualFold("NextMarker", t.Name.Local): 8139 val, err := decoder.Value() 8140 if err != nil { 8141 return err 8142 } 8143 if val == nil { 8144 break 8145 } 8146 { 8147 xtv := string(val) 8148 sv.NextMarker = ptr.String(xtv) 8149 } 8150 8151 case strings.EqualFold("Prefix", t.Name.Local): 8152 val, err := decoder.Value() 8153 if err != nil { 8154 return err 8155 } 8156 if val == nil { 8157 break 8158 } 8159 { 8160 xtv := string(val) 8161 sv.Prefix = ptr.String(xtv) 8162 } 8163 8164 default: 8165 // Do nothing and ignore the unexpected tag element 8166 err = decoder.Decoder.Skip() 8167 if err != nil { 8168 return err 8169 } 8170 8171 } 8172 decoder = originalDecoder 8173 } 8174 *v = sv 8175 return nil 8176} 8177 8178type awsRestxml_deserializeOpListObjectsV2 struct { 8179} 8180 8181func (*awsRestxml_deserializeOpListObjectsV2) ID() string { 8182 return "OperationDeserializer" 8183} 8184 8185func (m *awsRestxml_deserializeOpListObjectsV2) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8186 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8187) { 8188 out, metadata, err = next.HandleDeserialize(ctx, in) 8189 if err != nil { 8190 return out, metadata, err 8191 } 8192 8193 response, ok := out.RawResponse.(*smithyhttp.Response) 8194 if !ok { 8195 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8196 } 8197 8198 if response.StatusCode < 200 || response.StatusCode >= 300 { 8199 return out, metadata, awsRestxml_deserializeOpErrorListObjectsV2(response, &metadata) 8200 } 8201 output := &ListObjectsV2Output{} 8202 out.Result = output 8203 8204 var buff [1024]byte 8205 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8206 body := io.TeeReader(response.Body, ringBuffer) 8207 rootDecoder := xml.NewDecoder(body) 8208 t, err := smithyxml.FetchRootElement(rootDecoder) 8209 if err == io.EOF { 8210 return out, metadata, nil 8211 } 8212 if err != nil { 8213 var snapshot bytes.Buffer 8214 io.Copy(&snapshot, ringBuffer) 8215 return out, metadata, &smithy.DeserializationError{ 8216 Err: fmt.Errorf("failed to decode response body, %w", err), 8217 Snapshot: snapshot.Bytes(), 8218 } 8219 } 8220 8221 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8222 err = awsRestxml_deserializeOpDocumentListObjectsV2Output(&output, decoder) 8223 if err != nil { 8224 var snapshot bytes.Buffer 8225 io.Copy(&snapshot, ringBuffer) 8226 return out, metadata, &smithy.DeserializationError{ 8227 Err: fmt.Errorf("failed to decode response body, %w", err), 8228 Snapshot: snapshot.Bytes(), 8229 } 8230 } 8231 8232 return out, metadata, err 8233} 8234 8235func awsRestxml_deserializeOpErrorListObjectsV2(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8236 var errorBuffer bytes.Buffer 8237 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8238 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8239 } 8240 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8241 8242 errorCode := "UnknownError" 8243 errorMessage := errorCode 8244 8245 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 8246 UseStatusCode: true, StatusCode: response.StatusCode, 8247 }) 8248 if err != nil { 8249 return err 8250 } 8251 if hostID := errorComponents.HostID; len(hostID) != 0 { 8252 s3shared.SetHostIDMetadata(metadata, hostID) 8253 } 8254 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8255 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8256 } 8257 if len(errorComponents.Code) != 0 { 8258 errorCode = errorComponents.Code 8259 } 8260 if len(errorComponents.Message) != 0 { 8261 errorMessage = errorComponents.Message 8262 } 8263 errorBody.Seek(0, io.SeekStart) 8264 switch { 8265 case strings.EqualFold("NoSuchBucket", errorCode): 8266 return awsRestxml_deserializeErrorNoSuchBucket(response, errorBody) 8267 8268 default: 8269 genericError := &smithy.GenericAPIError{ 8270 Code: errorCode, 8271 Message: errorMessage, 8272 } 8273 return genericError 8274 8275 } 8276} 8277 8278func awsRestxml_deserializeOpDocumentListObjectsV2Output(v **ListObjectsV2Output, decoder smithyxml.NodeDecoder) error { 8279 if v == nil { 8280 return fmt.Errorf("unexpected nil of type %T", v) 8281 } 8282 var sv *ListObjectsV2Output 8283 if *v == nil { 8284 sv = &ListObjectsV2Output{} 8285 } else { 8286 sv = *v 8287 } 8288 8289 for { 8290 t, done, err := decoder.Token() 8291 if err != nil { 8292 return err 8293 } 8294 if done { 8295 break 8296 } 8297 originalDecoder := decoder 8298 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8299 switch { 8300 case strings.EqualFold("CommonPrefixes", t.Name.Local): 8301 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8302 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 8303 return err 8304 } 8305 8306 case strings.EqualFold("Contents", t.Name.Local): 8307 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8308 if err := awsRestxml_deserializeDocumentObjectListUnwrapped(&sv.Contents, nodeDecoder); err != nil { 8309 return err 8310 } 8311 8312 case strings.EqualFold("ContinuationToken", t.Name.Local): 8313 val, err := decoder.Value() 8314 if err != nil { 8315 return err 8316 } 8317 if val == nil { 8318 break 8319 } 8320 { 8321 xtv := string(val) 8322 sv.ContinuationToken = ptr.String(xtv) 8323 } 8324 8325 case strings.EqualFold("Delimiter", t.Name.Local): 8326 val, err := decoder.Value() 8327 if err != nil { 8328 return err 8329 } 8330 if val == nil { 8331 break 8332 } 8333 { 8334 xtv := string(val) 8335 sv.Delimiter = ptr.String(xtv) 8336 } 8337 8338 case strings.EqualFold("EncodingType", t.Name.Local): 8339 val, err := decoder.Value() 8340 if err != nil { 8341 return err 8342 } 8343 if val == nil { 8344 break 8345 } 8346 { 8347 xtv := string(val) 8348 sv.EncodingType = types.EncodingType(xtv) 8349 } 8350 8351 case strings.EqualFold("IsTruncated", t.Name.Local): 8352 val, err := decoder.Value() 8353 if err != nil { 8354 return err 8355 } 8356 if val == nil { 8357 break 8358 } 8359 { 8360 xtv, err := strconv.ParseBool(string(val)) 8361 if err != nil { 8362 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8363 } 8364 sv.IsTruncated = xtv 8365 } 8366 8367 case strings.EqualFold("KeyCount", t.Name.Local): 8368 val, err := decoder.Value() 8369 if err != nil { 8370 return err 8371 } 8372 if val == nil { 8373 break 8374 } 8375 { 8376 xtv := string(val) 8377 i64, err := strconv.ParseInt(xtv, 10, 64) 8378 if err != nil { 8379 return err 8380 } 8381 sv.KeyCount = int32(i64) 8382 } 8383 8384 case strings.EqualFold("MaxKeys", t.Name.Local): 8385 val, err := decoder.Value() 8386 if err != nil { 8387 return err 8388 } 8389 if val == nil { 8390 break 8391 } 8392 { 8393 xtv := string(val) 8394 i64, err := strconv.ParseInt(xtv, 10, 64) 8395 if err != nil { 8396 return err 8397 } 8398 sv.MaxKeys = int32(i64) 8399 } 8400 8401 case strings.EqualFold("Name", t.Name.Local): 8402 val, err := decoder.Value() 8403 if err != nil { 8404 return err 8405 } 8406 if val == nil { 8407 break 8408 } 8409 { 8410 xtv := string(val) 8411 sv.Name = ptr.String(xtv) 8412 } 8413 8414 case strings.EqualFold("NextContinuationToken", t.Name.Local): 8415 val, err := decoder.Value() 8416 if err != nil { 8417 return err 8418 } 8419 if val == nil { 8420 break 8421 } 8422 { 8423 xtv := string(val) 8424 sv.NextContinuationToken = ptr.String(xtv) 8425 } 8426 8427 case strings.EqualFold("Prefix", t.Name.Local): 8428 val, err := decoder.Value() 8429 if err != nil { 8430 return err 8431 } 8432 if val == nil { 8433 break 8434 } 8435 { 8436 xtv := string(val) 8437 sv.Prefix = ptr.String(xtv) 8438 } 8439 8440 case strings.EqualFold("StartAfter", t.Name.Local): 8441 val, err := decoder.Value() 8442 if err != nil { 8443 return err 8444 } 8445 if val == nil { 8446 break 8447 } 8448 { 8449 xtv := string(val) 8450 sv.StartAfter = ptr.String(xtv) 8451 } 8452 8453 default: 8454 // Do nothing and ignore the unexpected tag element 8455 err = decoder.Decoder.Skip() 8456 if err != nil { 8457 return err 8458 } 8459 8460 } 8461 decoder = originalDecoder 8462 } 8463 *v = sv 8464 return nil 8465} 8466 8467type awsRestxml_deserializeOpListObjectVersions struct { 8468} 8469 8470func (*awsRestxml_deserializeOpListObjectVersions) ID() string { 8471 return "OperationDeserializer" 8472} 8473 8474func (m *awsRestxml_deserializeOpListObjectVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8475 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8476) { 8477 out, metadata, err = next.HandleDeserialize(ctx, in) 8478 if err != nil { 8479 return out, metadata, err 8480 } 8481 8482 response, ok := out.RawResponse.(*smithyhttp.Response) 8483 if !ok { 8484 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8485 } 8486 8487 if response.StatusCode < 200 || response.StatusCode >= 300 { 8488 return out, metadata, awsRestxml_deserializeOpErrorListObjectVersions(response, &metadata) 8489 } 8490 output := &ListObjectVersionsOutput{} 8491 out.Result = output 8492 8493 var buff [1024]byte 8494 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8495 body := io.TeeReader(response.Body, ringBuffer) 8496 rootDecoder := xml.NewDecoder(body) 8497 t, err := smithyxml.FetchRootElement(rootDecoder) 8498 if err == io.EOF { 8499 return out, metadata, nil 8500 } 8501 if err != nil { 8502 var snapshot bytes.Buffer 8503 io.Copy(&snapshot, ringBuffer) 8504 return out, metadata, &smithy.DeserializationError{ 8505 Err: fmt.Errorf("failed to decode response body, %w", err), 8506 Snapshot: snapshot.Bytes(), 8507 } 8508 } 8509 8510 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8511 err = awsRestxml_deserializeOpDocumentListObjectVersionsOutput(&output, decoder) 8512 if err != nil { 8513 var snapshot bytes.Buffer 8514 io.Copy(&snapshot, ringBuffer) 8515 return out, metadata, &smithy.DeserializationError{ 8516 Err: fmt.Errorf("failed to decode response body, %w", err), 8517 Snapshot: snapshot.Bytes(), 8518 } 8519 } 8520 8521 return out, metadata, err 8522} 8523 8524func awsRestxml_deserializeOpErrorListObjectVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8525 var errorBuffer bytes.Buffer 8526 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8527 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8528 } 8529 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8530 8531 errorCode := "UnknownError" 8532 errorMessage := errorCode 8533 8534 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 8535 UseStatusCode: true, StatusCode: response.StatusCode, 8536 }) 8537 if err != nil { 8538 return err 8539 } 8540 if hostID := errorComponents.HostID; len(hostID) != 0 { 8541 s3shared.SetHostIDMetadata(metadata, hostID) 8542 } 8543 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8544 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8545 } 8546 if len(errorComponents.Code) != 0 { 8547 errorCode = errorComponents.Code 8548 } 8549 if len(errorComponents.Message) != 0 { 8550 errorMessage = errorComponents.Message 8551 } 8552 errorBody.Seek(0, io.SeekStart) 8553 switch { 8554 default: 8555 genericError := &smithy.GenericAPIError{ 8556 Code: errorCode, 8557 Message: errorMessage, 8558 } 8559 return genericError 8560 8561 } 8562} 8563 8564func awsRestxml_deserializeOpDocumentListObjectVersionsOutput(v **ListObjectVersionsOutput, decoder smithyxml.NodeDecoder) error { 8565 if v == nil { 8566 return fmt.Errorf("unexpected nil of type %T", v) 8567 } 8568 var sv *ListObjectVersionsOutput 8569 if *v == nil { 8570 sv = &ListObjectVersionsOutput{} 8571 } else { 8572 sv = *v 8573 } 8574 8575 for { 8576 t, done, err := decoder.Token() 8577 if err != nil { 8578 return err 8579 } 8580 if done { 8581 break 8582 } 8583 originalDecoder := decoder 8584 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8585 switch { 8586 case strings.EqualFold("CommonPrefixes", t.Name.Local): 8587 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8588 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 8589 return err 8590 } 8591 8592 case strings.EqualFold("DeleteMarker", t.Name.Local): 8593 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8594 if err := awsRestxml_deserializeDocumentDeleteMarkersUnwrapped(&sv.DeleteMarkers, nodeDecoder); err != nil { 8595 return err 8596 } 8597 8598 case strings.EqualFold("Delimiter", t.Name.Local): 8599 val, err := decoder.Value() 8600 if err != nil { 8601 return err 8602 } 8603 if val == nil { 8604 break 8605 } 8606 { 8607 xtv := string(val) 8608 sv.Delimiter = ptr.String(xtv) 8609 } 8610 8611 case strings.EqualFold("EncodingType", t.Name.Local): 8612 val, err := decoder.Value() 8613 if err != nil { 8614 return err 8615 } 8616 if val == nil { 8617 break 8618 } 8619 { 8620 xtv := string(val) 8621 sv.EncodingType = types.EncodingType(xtv) 8622 } 8623 8624 case strings.EqualFold("IsTruncated", t.Name.Local): 8625 val, err := decoder.Value() 8626 if err != nil { 8627 return err 8628 } 8629 if val == nil { 8630 break 8631 } 8632 { 8633 xtv, err := strconv.ParseBool(string(val)) 8634 if err != nil { 8635 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8636 } 8637 sv.IsTruncated = xtv 8638 } 8639 8640 case strings.EqualFold("KeyMarker", t.Name.Local): 8641 val, err := decoder.Value() 8642 if err != nil { 8643 return err 8644 } 8645 if val == nil { 8646 break 8647 } 8648 { 8649 xtv := string(val) 8650 sv.KeyMarker = ptr.String(xtv) 8651 } 8652 8653 case strings.EqualFold("MaxKeys", t.Name.Local): 8654 val, err := decoder.Value() 8655 if err != nil { 8656 return err 8657 } 8658 if val == nil { 8659 break 8660 } 8661 { 8662 xtv := string(val) 8663 i64, err := strconv.ParseInt(xtv, 10, 64) 8664 if err != nil { 8665 return err 8666 } 8667 sv.MaxKeys = int32(i64) 8668 } 8669 8670 case strings.EqualFold("Name", t.Name.Local): 8671 val, err := decoder.Value() 8672 if err != nil { 8673 return err 8674 } 8675 if val == nil { 8676 break 8677 } 8678 { 8679 xtv := string(val) 8680 sv.Name = ptr.String(xtv) 8681 } 8682 8683 case strings.EqualFold("NextKeyMarker", t.Name.Local): 8684 val, err := decoder.Value() 8685 if err != nil { 8686 return err 8687 } 8688 if val == nil { 8689 break 8690 } 8691 { 8692 xtv := string(val) 8693 sv.NextKeyMarker = ptr.String(xtv) 8694 } 8695 8696 case strings.EqualFold("NextVersionIdMarker", t.Name.Local): 8697 val, err := decoder.Value() 8698 if err != nil { 8699 return err 8700 } 8701 if val == nil { 8702 break 8703 } 8704 { 8705 xtv := string(val) 8706 sv.NextVersionIdMarker = ptr.String(xtv) 8707 } 8708 8709 case strings.EqualFold("Prefix", t.Name.Local): 8710 val, err := decoder.Value() 8711 if err != nil { 8712 return err 8713 } 8714 if val == nil { 8715 break 8716 } 8717 { 8718 xtv := string(val) 8719 sv.Prefix = ptr.String(xtv) 8720 } 8721 8722 case strings.EqualFold("VersionIdMarker", t.Name.Local): 8723 val, err := decoder.Value() 8724 if err != nil { 8725 return err 8726 } 8727 if val == nil { 8728 break 8729 } 8730 { 8731 xtv := string(val) 8732 sv.VersionIdMarker = ptr.String(xtv) 8733 } 8734 8735 case strings.EqualFold("Version", t.Name.Local): 8736 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8737 if err := awsRestxml_deserializeDocumentObjectVersionListUnwrapped(&sv.Versions, nodeDecoder); err != nil { 8738 return err 8739 } 8740 8741 default: 8742 // Do nothing and ignore the unexpected tag element 8743 err = decoder.Decoder.Skip() 8744 if err != nil { 8745 return err 8746 } 8747 8748 } 8749 decoder = originalDecoder 8750 } 8751 *v = sv 8752 return nil 8753} 8754 8755type awsRestxml_deserializeOpListParts struct { 8756} 8757 8758func (*awsRestxml_deserializeOpListParts) ID() string { 8759 return "OperationDeserializer" 8760} 8761 8762func (m *awsRestxml_deserializeOpListParts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8763 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8764) { 8765 out, metadata, err = next.HandleDeserialize(ctx, in) 8766 if err != nil { 8767 return out, metadata, err 8768 } 8769 8770 response, ok := out.RawResponse.(*smithyhttp.Response) 8771 if !ok { 8772 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8773 } 8774 8775 if response.StatusCode < 200 || response.StatusCode >= 300 { 8776 return out, metadata, awsRestxml_deserializeOpErrorListParts(response, &metadata) 8777 } 8778 output := &ListPartsOutput{} 8779 out.Result = output 8780 8781 err = awsRestxml_deserializeOpHttpBindingsListPartsOutput(output, response) 8782 if err != nil { 8783 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 8784 } 8785 8786 var buff [1024]byte 8787 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8788 body := io.TeeReader(response.Body, ringBuffer) 8789 rootDecoder := xml.NewDecoder(body) 8790 t, err := smithyxml.FetchRootElement(rootDecoder) 8791 if err == io.EOF { 8792 return out, metadata, nil 8793 } 8794 if err != nil { 8795 var snapshot bytes.Buffer 8796 io.Copy(&snapshot, ringBuffer) 8797 return out, metadata, &smithy.DeserializationError{ 8798 Err: fmt.Errorf("failed to decode response body, %w", err), 8799 Snapshot: snapshot.Bytes(), 8800 } 8801 } 8802 8803 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8804 err = awsRestxml_deserializeOpDocumentListPartsOutput(&output, decoder) 8805 if err != nil { 8806 var snapshot bytes.Buffer 8807 io.Copy(&snapshot, ringBuffer) 8808 return out, metadata, &smithy.DeserializationError{ 8809 Err: fmt.Errorf("failed to decode response body, %w", err), 8810 Snapshot: snapshot.Bytes(), 8811 } 8812 } 8813 8814 return out, metadata, err 8815} 8816 8817func awsRestxml_deserializeOpErrorListParts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8818 var errorBuffer bytes.Buffer 8819 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8820 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8821 } 8822 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8823 8824 errorCode := "UnknownError" 8825 errorMessage := errorCode 8826 8827 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 8828 UseStatusCode: true, StatusCode: response.StatusCode, 8829 }) 8830 if err != nil { 8831 return err 8832 } 8833 if hostID := errorComponents.HostID; len(hostID) != 0 { 8834 s3shared.SetHostIDMetadata(metadata, hostID) 8835 } 8836 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8837 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8838 } 8839 if len(errorComponents.Code) != 0 { 8840 errorCode = errorComponents.Code 8841 } 8842 if len(errorComponents.Message) != 0 { 8843 errorMessage = errorComponents.Message 8844 } 8845 errorBody.Seek(0, io.SeekStart) 8846 switch { 8847 default: 8848 genericError := &smithy.GenericAPIError{ 8849 Code: errorCode, 8850 Message: errorMessage, 8851 } 8852 return genericError 8853 8854 } 8855} 8856 8857func awsRestxml_deserializeOpHttpBindingsListPartsOutput(v *ListPartsOutput, response *smithyhttp.Response) error { 8858 if v == nil { 8859 return fmt.Errorf("unsupported deserialization for nil %T", v) 8860 } 8861 8862 if headerValues := response.Header.Values("x-amz-abort-date"); len(headerValues) != 0 { 8863 headerValues[0] = strings.TrimSpace(headerValues[0]) 8864 t, err := smithytime.ParseHTTPDate(headerValues[0]) 8865 if err != nil { 8866 return err 8867 } 8868 v.AbortDate = ptr.Time(t) 8869 } 8870 8871 if headerValues := response.Header.Values("x-amz-abort-rule-id"); len(headerValues) != 0 { 8872 headerValues[0] = strings.TrimSpace(headerValues[0]) 8873 v.AbortRuleId = ptr.String(headerValues[0]) 8874 } 8875 8876 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 8877 headerValues[0] = strings.TrimSpace(headerValues[0]) 8878 v.RequestCharged = types.RequestCharged(headerValues[0]) 8879 } 8880 8881 return nil 8882} 8883func awsRestxml_deserializeOpDocumentListPartsOutput(v **ListPartsOutput, decoder smithyxml.NodeDecoder) error { 8884 if v == nil { 8885 return fmt.Errorf("unexpected nil of type %T", v) 8886 } 8887 var sv *ListPartsOutput 8888 if *v == nil { 8889 sv = &ListPartsOutput{} 8890 } else { 8891 sv = *v 8892 } 8893 8894 for { 8895 t, done, err := decoder.Token() 8896 if err != nil { 8897 return err 8898 } 8899 if done { 8900 break 8901 } 8902 originalDecoder := decoder 8903 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8904 switch { 8905 case strings.EqualFold("Bucket", t.Name.Local): 8906 val, err := decoder.Value() 8907 if err != nil { 8908 return err 8909 } 8910 if val == nil { 8911 break 8912 } 8913 { 8914 xtv := string(val) 8915 sv.Bucket = ptr.String(xtv) 8916 } 8917 8918 case strings.EqualFold("Initiator", t.Name.Local): 8919 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8920 if err := awsRestxml_deserializeDocumentInitiator(&sv.Initiator, nodeDecoder); err != nil { 8921 return err 8922 } 8923 8924 case strings.EqualFold("IsTruncated", t.Name.Local): 8925 val, err := decoder.Value() 8926 if err != nil { 8927 return err 8928 } 8929 if val == nil { 8930 break 8931 } 8932 { 8933 xtv, err := strconv.ParseBool(string(val)) 8934 if err != nil { 8935 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8936 } 8937 sv.IsTruncated = xtv 8938 } 8939 8940 case strings.EqualFold("Key", t.Name.Local): 8941 val, err := decoder.Value() 8942 if err != nil { 8943 return err 8944 } 8945 if val == nil { 8946 break 8947 } 8948 { 8949 xtv := string(val) 8950 sv.Key = ptr.String(xtv) 8951 } 8952 8953 case strings.EqualFold("MaxParts", t.Name.Local): 8954 val, err := decoder.Value() 8955 if err != nil { 8956 return err 8957 } 8958 if val == nil { 8959 break 8960 } 8961 { 8962 xtv := string(val) 8963 i64, err := strconv.ParseInt(xtv, 10, 64) 8964 if err != nil { 8965 return err 8966 } 8967 sv.MaxParts = int32(i64) 8968 } 8969 8970 case strings.EqualFold("NextPartNumberMarker", t.Name.Local): 8971 val, err := decoder.Value() 8972 if err != nil { 8973 return err 8974 } 8975 if val == nil { 8976 break 8977 } 8978 { 8979 xtv := string(val) 8980 sv.NextPartNumberMarker = ptr.String(xtv) 8981 } 8982 8983 case strings.EqualFold("Owner", t.Name.Local): 8984 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8985 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 8986 return err 8987 } 8988 8989 case strings.EqualFold("PartNumberMarker", t.Name.Local): 8990 val, err := decoder.Value() 8991 if err != nil { 8992 return err 8993 } 8994 if val == nil { 8995 break 8996 } 8997 { 8998 xtv := string(val) 8999 sv.PartNumberMarker = ptr.String(xtv) 9000 } 9001 9002 case strings.EqualFold("Part", t.Name.Local): 9003 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 9004 if err := awsRestxml_deserializeDocumentPartsUnwrapped(&sv.Parts, nodeDecoder); err != nil { 9005 return err 9006 } 9007 9008 case strings.EqualFold("StorageClass", t.Name.Local): 9009 val, err := decoder.Value() 9010 if err != nil { 9011 return err 9012 } 9013 if val == nil { 9014 break 9015 } 9016 { 9017 xtv := string(val) 9018 sv.StorageClass = types.StorageClass(xtv) 9019 } 9020 9021 case strings.EqualFold("UploadId", t.Name.Local): 9022 val, err := decoder.Value() 9023 if err != nil { 9024 return err 9025 } 9026 if val == nil { 9027 break 9028 } 9029 { 9030 xtv := string(val) 9031 sv.UploadId = ptr.String(xtv) 9032 } 9033 9034 default: 9035 // Do nothing and ignore the unexpected tag element 9036 err = decoder.Decoder.Skip() 9037 if err != nil { 9038 return err 9039 } 9040 9041 } 9042 decoder = originalDecoder 9043 } 9044 *v = sv 9045 return nil 9046} 9047 9048type awsRestxml_deserializeOpPutBucketAccelerateConfiguration struct { 9049} 9050 9051func (*awsRestxml_deserializeOpPutBucketAccelerateConfiguration) ID() string { 9052 return "OperationDeserializer" 9053} 9054 9055func (m *awsRestxml_deserializeOpPutBucketAccelerateConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9056 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9057) { 9058 out, metadata, err = next.HandleDeserialize(ctx, in) 9059 if err != nil { 9060 return out, metadata, err 9061 } 9062 9063 response, ok := out.RawResponse.(*smithyhttp.Response) 9064 if !ok { 9065 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9066 } 9067 9068 if response.StatusCode < 200 || response.StatusCode >= 300 { 9069 return out, metadata, awsRestxml_deserializeOpErrorPutBucketAccelerateConfiguration(response, &metadata) 9070 } 9071 output := &PutBucketAccelerateConfigurationOutput{} 9072 out.Result = output 9073 9074 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9075 return out, metadata, &smithy.DeserializationError{ 9076 Err: fmt.Errorf("failed to discard response body, %w", err), 9077 } 9078 } 9079 9080 return out, metadata, err 9081} 9082 9083func awsRestxml_deserializeOpErrorPutBucketAccelerateConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9084 var errorBuffer bytes.Buffer 9085 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9086 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9087 } 9088 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9089 9090 errorCode := "UnknownError" 9091 errorMessage := errorCode 9092 9093 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9094 UseStatusCode: true, StatusCode: response.StatusCode, 9095 }) 9096 if err != nil { 9097 return err 9098 } 9099 if hostID := errorComponents.HostID; len(hostID) != 0 { 9100 s3shared.SetHostIDMetadata(metadata, hostID) 9101 } 9102 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9103 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9104 } 9105 if len(errorComponents.Code) != 0 { 9106 errorCode = errorComponents.Code 9107 } 9108 if len(errorComponents.Message) != 0 { 9109 errorMessage = errorComponents.Message 9110 } 9111 errorBody.Seek(0, io.SeekStart) 9112 switch { 9113 default: 9114 genericError := &smithy.GenericAPIError{ 9115 Code: errorCode, 9116 Message: errorMessage, 9117 } 9118 return genericError 9119 9120 } 9121} 9122 9123type awsRestxml_deserializeOpPutBucketAcl struct { 9124} 9125 9126func (*awsRestxml_deserializeOpPutBucketAcl) ID() string { 9127 return "OperationDeserializer" 9128} 9129 9130func (m *awsRestxml_deserializeOpPutBucketAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9131 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9132) { 9133 out, metadata, err = next.HandleDeserialize(ctx, in) 9134 if err != nil { 9135 return out, metadata, err 9136 } 9137 9138 response, ok := out.RawResponse.(*smithyhttp.Response) 9139 if !ok { 9140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9141 } 9142 9143 if response.StatusCode < 200 || response.StatusCode >= 300 { 9144 return out, metadata, awsRestxml_deserializeOpErrorPutBucketAcl(response, &metadata) 9145 } 9146 output := &PutBucketAclOutput{} 9147 out.Result = output 9148 9149 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9150 return out, metadata, &smithy.DeserializationError{ 9151 Err: fmt.Errorf("failed to discard response body, %w", err), 9152 } 9153 } 9154 9155 return out, metadata, err 9156} 9157 9158func awsRestxml_deserializeOpErrorPutBucketAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9159 var errorBuffer bytes.Buffer 9160 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9161 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9162 } 9163 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9164 9165 errorCode := "UnknownError" 9166 errorMessage := errorCode 9167 9168 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9169 UseStatusCode: true, StatusCode: response.StatusCode, 9170 }) 9171 if err != nil { 9172 return err 9173 } 9174 if hostID := errorComponents.HostID; len(hostID) != 0 { 9175 s3shared.SetHostIDMetadata(metadata, hostID) 9176 } 9177 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9178 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9179 } 9180 if len(errorComponents.Code) != 0 { 9181 errorCode = errorComponents.Code 9182 } 9183 if len(errorComponents.Message) != 0 { 9184 errorMessage = errorComponents.Message 9185 } 9186 errorBody.Seek(0, io.SeekStart) 9187 switch { 9188 default: 9189 genericError := &smithy.GenericAPIError{ 9190 Code: errorCode, 9191 Message: errorMessage, 9192 } 9193 return genericError 9194 9195 } 9196} 9197 9198type awsRestxml_deserializeOpPutBucketAnalyticsConfiguration struct { 9199} 9200 9201func (*awsRestxml_deserializeOpPutBucketAnalyticsConfiguration) ID() string { 9202 return "OperationDeserializer" 9203} 9204 9205func (m *awsRestxml_deserializeOpPutBucketAnalyticsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9206 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9207) { 9208 out, metadata, err = next.HandleDeserialize(ctx, in) 9209 if err != nil { 9210 return out, metadata, err 9211 } 9212 9213 response, ok := out.RawResponse.(*smithyhttp.Response) 9214 if !ok { 9215 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9216 } 9217 9218 if response.StatusCode < 200 || response.StatusCode >= 300 { 9219 return out, metadata, awsRestxml_deserializeOpErrorPutBucketAnalyticsConfiguration(response, &metadata) 9220 } 9221 output := &PutBucketAnalyticsConfigurationOutput{} 9222 out.Result = output 9223 9224 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9225 return out, metadata, &smithy.DeserializationError{ 9226 Err: fmt.Errorf("failed to discard response body, %w", err), 9227 } 9228 } 9229 9230 return out, metadata, err 9231} 9232 9233func awsRestxml_deserializeOpErrorPutBucketAnalyticsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9234 var errorBuffer bytes.Buffer 9235 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9236 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9237 } 9238 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9239 9240 errorCode := "UnknownError" 9241 errorMessage := errorCode 9242 9243 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9244 UseStatusCode: true, StatusCode: response.StatusCode, 9245 }) 9246 if err != nil { 9247 return err 9248 } 9249 if hostID := errorComponents.HostID; len(hostID) != 0 { 9250 s3shared.SetHostIDMetadata(metadata, hostID) 9251 } 9252 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9253 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9254 } 9255 if len(errorComponents.Code) != 0 { 9256 errorCode = errorComponents.Code 9257 } 9258 if len(errorComponents.Message) != 0 { 9259 errorMessage = errorComponents.Message 9260 } 9261 errorBody.Seek(0, io.SeekStart) 9262 switch { 9263 default: 9264 genericError := &smithy.GenericAPIError{ 9265 Code: errorCode, 9266 Message: errorMessage, 9267 } 9268 return genericError 9269 9270 } 9271} 9272 9273type awsRestxml_deserializeOpPutBucketCors struct { 9274} 9275 9276func (*awsRestxml_deserializeOpPutBucketCors) ID() string { 9277 return "OperationDeserializer" 9278} 9279 9280func (m *awsRestxml_deserializeOpPutBucketCors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9281 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9282) { 9283 out, metadata, err = next.HandleDeserialize(ctx, in) 9284 if err != nil { 9285 return out, metadata, err 9286 } 9287 9288 response, ok := out.RawResponse.(*smithyhttp.Response) 9289 if !ok { 9290 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9291 } 9292 9293 if response.StatusCode < 200 || response.StatusCode >= 300 { 9294 return out, metadata, awsRestxml_deserializeOpErrorPutBucketCors(response, &metadata) 9295 } 9296 output := &PutBucketCorsOutput{} 9297 out.Result = output 9298 9299 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9300 return out, metadata, &smithy.DeserializationError{ 9301 Err: fmt.Errorf("failed to discard response body, %w", err), 9302 } 9303 } 9304 9305 return out, metadata, err 9306} 9307 9308func awsRestxml_deserializeOpErrorPutBucketCors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9309 var errorBuffer bytes.Buffer 9310 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9311 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9312 } 9313 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9314 9315 errorCode := "UnknownError" 9316 errorMessage := errorCode 9317 9318 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9319 UseStatusCode: true, StatusCode: response.StatusCode, 9320 }) 9321 if err != nil { 9322 return err 9323 } 9324 if hostID := errorComponents.HostID; len(hostID) != 0 { 9325 s3shared.SetHostIDMetadata(metadata, hostID) 9326 } 9327 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9328 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9329 } 9330 if len(errorComponents.Code) != 0 { 9331 errorCode = errorComponents.Code 9332 } 9333 if len(errorComponents.Message) != 0 { 9334 errorMessage = errorComponents.Message 9335 } 9336 errorBody.Seek(0, io.SeekStart) 9337 switch { 9338 default: 9339 genericError := &smithy.GenericAPIError{ 9340 Code: errorCode, 9341 Message: errorMessage, 9342 } 9343 return genericError 9344 9345 } 9346} 9347 9348type awsRestxml_deserializeOpPutBucketEncryption struct { 9349} 9350 9351func (*awsRestxml_deserializeOpPutBucketEncryption) ID() string { 9352 return "OperationDeserializer" 9353} 9354 9355func (m *awsRestxml_deserializeOpPutBucketEncryption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9356 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9357) { 9358 out, metadata, err = next.HandleDeserialize(ctx, in) 9359 if err != nil { 9360 return out, metadata, err 9361 } 9362 9363 response, ok := out.RawResponse.(*smithyhttp.Response) 9364 if !ok { 9365 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9366 } 9367 9368 if response.StatusCode < 200 || response.StatusCode >= 300 { 9369 return out, metadata, awsRestxml_deserializeOpErrorPutBucketEncryption(response, &metadata) 9370 } 9371 output := &PutBucketEncryptionOutput{} 9372 out.Result = output 9373 9374 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9375 return out, metadata, &smithy.DeserializationError{ 9376 Err: fmt.Errorf("failed to discard response body, %w", err), 9377 } 9378 } 9379 9380 return out, metadata, err 9381} 9382 9383func awsRestxml_deserializeOpErrorPutBucketEncryption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9384 var errorBuffer bytes.Buffer 9385 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9386 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9387 } 9388 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9389 9390 errorCode := "UnknownError" 9391 errorMessage := errorCode 9392 9393 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9394 UseStatusCode: true, StatusCode: response.StatusCode, 9395 }) 9396 if err != nil { 9397 return err 9398 } 9399 if hostID := errorComponents.HostID; len(hostID) != 0 { 9400 s3shared.SetHostIDMetadata(metadata, hostID) 9401 } 9402 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9403 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9404 } 9405 if len(errorComponents.Code) != 0 { 9406 errorCode = errorComponents.Code 9407 } 9408 if len(errorComponents.Message) != 0 { 9409 errorMessage = errorComponents.Message 9410 } 9411 errorBody.Seek(0, io.SeekStart) 9412 switch { 9413 default: 9414 genericError := &smithy.GenericAPIError{ 9415 Code: errorCode, 9416 Message: errorMessage, 9417 } 9418 return genericError 9419 9420 } 9421} 9422 9423type awsRestxml_deserializeOpPutBucketIntelligentTieringConfiguration struct { 9424} 9425 9426func (*awsRestxml_deserializeOpPutBucketIntelligentTieringConfiguration) ID() string { 9427 return "OperationDeserializer" 9428} 9429 9430func (m *awsRestxml_deserializeOpPutBucketIntelligentTieringConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9431 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9432) { 9433 out, metadata, err = next.HandleDeserialize(ctx, in) 9434 if err != nil { 9435 return out, metadata, err 9436 } 9437 9438 response, ok := out.RawResponse.(*smithyhttp.Response) 9439 if !ok { 9440 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9441 } 9442 9443 if response.StatusCode < 200 || response.StatusCode >= 300 { 9444 return out, metadata, awsRestxml_deserializeOpErrorPutBucketIntelligentTieringConfiguration(response, &metadata) 9445 } 9446 output := &PutBucketIntelligentTieringConfigurationOutput{} 9447 out.Result = output 9448 9449 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9450 return out, metadata, &smithy.DeserializationError{ 9451 Err: fmt.Errorf("failed to discard response body, %w", err), 9452 } 9453 } 9454 9455 return out, metadata, err 9456} 9457 9458func awsRestxml_deserializeOpErrorPutBucketIntelligentTieringConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9459 var errorBuffer bytes.Buffer 9460 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9461 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9462 } 9463 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9464 9465 errorCode := "UnknownError" 9466 errorMessage := errorCode 9467 9468 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9469 UseStatusCode: true, StatusCode: response.StatusCode, 9470 }) 9471 if err != nil { 9472 return err 9473 } 9474 if hostID := errorComponents.HostID; len(hostID) != 0 { 9475 s3shared.SetHostIDMetadata(metadata, hostID) 9476 } 9477 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9478 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9479 } 9480 if len(errorComponents.Code) != 0 { 9481 errorCode = errorComponents.Code 9482 } 9483 if len(errorComponents.Message) != 0 { 9484 errorMessage = errorComponents.Message 9485 } 9486 errorBody.Seek(0, io.SeekStart) 9487 switch { 9488 default: 9489 genericError := &smithy.GenericAPIError{ 9490 Code: errorCode, 9491 Message: errorMessage, 9492 } 9493 return genericError 9494 9495 } 9496} 9497 9498type awsRestxml_deserializeOpPutBucketInventoryConfiguration struct { 9499} 9500 9501func (*awsRestxml_deserializeOpPutBucketInventoryConfiguration) ID() string { 9502 return "OperationDeserializer" 9503} 9504 9505func (m *awsRestxml_deserializeOpPutBucketInventoryConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9506 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9507) { 9508 out, metadata, err = next.HandleDeserialize(ctx, in) 9509 if err != nil { 9510 return out, metadata, err 9511 } 9512 9513 response, ok := out.RawResponse.(*smithyhttp.Response) 9514 if !ok { 9515 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9516 } 9517 9518 if response.StatusCode < 200 || response.StatusCode >= 300 { 9519 return out, metadata, awsRestxml_deserializeOpErrorPutBucketInventoryConfiguration(response, &metadata) 9520 } 9521 output := &PutBucketInventoryConfigurationOutput{} 9522 out.Result = output 9523 9524 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9525 return out, metadata, &smithy.DeserializationError{ 9526 Err: fmt.Errorf("failed to discard response body, %w", err), 9527 } 9528 } 9529 9530 return out, metadata, err 9531} 9532 9533func awsRestxml_deserializeOpErrorPutBucketInventoryConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9534 var errorBuffer bytes.Buffer 9535 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9536 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9537 } 9538 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9539 9540 errorCode := "UnknownError" 9541 errorMessage := errorCode 9542 9543 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9544 UseStatusCode: true, StatusCode: response.StatusCode, 9545 }) 9546 if err != nil { 9547 return err 9548 } 9549 if hostID := errorComponents.HostID; len(hostID) != 0 { 9550 s3shared.SetHostIDMetadata(metadata, hostID) 9551 } 9552 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9553 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9554 } 9555 if len(errorComponents.Code) != 0 { 9556 errorCode = errorComponents.Code 9557 } 9558 if len(errorComponents.Message) != 0 { 9559 errorMessage = errorComponents.Message 9560 } 9561 errorBody.Seek(0, io.SeekStart) 9562 switch { 9563 default: 9564 genericError := &smithy.GenericAPIError{ 9565 Code: errorCode, 9566 Message: errorMessage, 9567 } 9568 return genericError 9569 9570 } 9571} 9572 9573type awsRestxml_deserializeOpPutBucketLifecycleConfiguration struct { 9574} 9575 9576func (*awsRestxml_deserializeOpPutBucketLifecycleConfiguration) ID() string { 9577 return "OperationDeserializer" 9578} 9579 9580func (m *awsRestxml_deserializeOpPutBucketLifecycleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9581 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9582) { 9583 out, metadata, err = next.HandleDeserialize(ctx, in) 9584 if err != nil { 9585 return out, metadata, err 9586 } 9587 9588 response, ok := out.RawResponse.(*smithyhttp.Response) 9589 if !ok { 9590 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9591 } 9592 9593 if response.StatusCode < 200 || response.StatusCode >= 300 { 9594 return out, metadata, awsRestxml_deserializeOpErrorPutBucketLifecycleConfiguration(response, &metadata) 9595 } 9596 output := &PutBucketLifecycleConfigurationOutput{} 9597 out.Result = output 9598 9599 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9600 return out, metadata, &smithy.DeserializationError{ 9601 Err: fmt.Errorf("failed to discard response body, %w", err), 9602 } 9603 } 9604 9605 return out, metadata, err 9606} 9607 9608func awsRestxml_deserializeOpErrorPutBucketLifecycleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9609 var errorBuffer bytes.Buffer 9610 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9611 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9612 } 9613 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9614 9615 errorCode := "UnknownError" 9616 errorMessage := errorCode 9617 9618 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9619 UseStatusCode: true, StatusCode: response.StatusCode, 9620 }) 9621 if err != nil { 9622 return err 9623 } 9624 if hostID := errorComponents.HostID; len(hostID) != 0 { 9625 s3shared.SetHostIDMetadata(metadata, hostID) 9626 } 9627 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9628 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9629 } 9630 if len(errorComponents.Code) != 0 { 9631 errorCode = errorComponents.Code 9632 } 9633 if len(errorComponents.Message) != 0 { 9634 errorMessage = errorComponents.Message 9635 } 9636 errorBody.Seek(0, io.SeekStart) 9637 switch { 9638 default: 9639 genericError := &smithy.GenericAPIError{ 9640 Code: errorCode, 9641 Message: errorMessage, 9642 } 9643 return genericError 9644 9645 } 9646} 9647 9648type awsRestxml_deserializeOpPutBucketLogging struct { 9649} 9650 9651func (*awsRestxml_deserializeOpPutBucketLogging) ID() string { 9652 return "OperationDeserializer" 9653} 9654 9655func (m *awsRestxml_deserializeOpPutBucketLogging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9656 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9657) { 9658 out, metadata, err = next.HandleDeserialize(ctx, in) 9659 if err != nil { 9660 return out, metadata, err 9661 } 9662 9663 response, ok := out.RawResponse.(*smithyhttp.Response) 9664 if !ok { 9665 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9666 } 9667 9668 if response.StatusCode < 200 || response.StatusCode >= 300 { 9669 return out, metadata, awsRestxml_deserializeOpErrorPutBucketLogging(response, &metadata) 9670 } 9671 output := &PutBucketLoggingOutput{} 9672 out.Result = output 9673 9674 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9675 return out, metadata, &smithy.DeserializationError{ 9676 Err: fmt.Errorf("failed to discard response body, %w", err), 9677 } 9678 } 9679 9680 return out, metadata, err 9681} 9682 9683func awsRestxml_deserializeOpErrorPutBucketLogging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9684 var errorBuffer bytes.Buffer 9685 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9686 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9687 } 9688 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9689 9690 errorCode := "UnknownError" 9691 errorMessage := errorCode 9692 9693 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9694 UseStatusCode: true, StatusCode: response.StatusCode, 9695 }) 9696 if err != nil { 9697 return err 9698 } 9699 if hostID := errorComponents.HostID; len(hostID) != 0 { 9700 s3shared.SetHostIDMetadata(metadata, hostID) 9701 } 9702 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9703 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9704 } 9705 if len(errorComponents.Code) != 0 { 9706 errorCode = errorComponents.Code 9707 } 9708 if len(errorComponents.Message) != 0 { 9709 errorMessage = errorComponents.Message 9710 } 9711 errorBody.Seek(0, io.SeekStart) 9712 switch { 9713 default: 9714 genericError := &smithy.GenericAPIError{ 9715 Code: errorCode, 9716 Message: errorMessage, 9717 } 9718 return genericError 9719 9720 } 9721} 9722 9723type awsRestxml_deserializeOpPutBucketMetricsConfiguration struct { 9724} 9725 9726func (*awsRestxml_deserializeOpPutBucketMetricsConfiguration) ID() string { 9727 return "OperationDeserializer" 9728} 9729 9730func (m *awsRestxml_deserializeOpPutBucketMetricsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9731 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9732) { 9733 out, metadata, err = next.HandleDeserialize(ctx, in) 9734 if err != nil { 9735 return out, metadata, err 9736 } 9737 9738 response, ok := out.RawResponse.(*smithyhttp.Response) 9739 if !ok { 9740 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9741 } 9742 9743 if response.StatusCode < 200 || response.StatusCode >= 300 { 9744 return out, metadata, awsRestxml_deserializeOpErrorPutBucketMetricsConfiguration(response, &metadata) 9745 } 9746 output := &PutBucketMetricsConfigurationOutput{} 9747 out.Result = output 9748 9749 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9750 return out, metadata, &smithy.DeserializationError{ 9751 Err: fmt.Errorf("failed to discard response body, %w", err), 9752 } 9753 } 9754 9755 return out, metadata, err 9756} 9757 9758func awsRestxml_deserializeOpErrorPutBucketMetricsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9759 var errorBuffer bytes.Buffer 9760 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9761 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9762 } 9763 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9764 9765 errorCode := "UnknownError" 9766 errorMessage := errorCode 9767 9768 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9769 UseStatusCode: true, StatusCode: response.StatusCode, 9770 }) 9771 if err != nil { 9772 return err 9773 } 9774 if hostID := errorComponents.HostID; len(hostID) != 0 { 9775 s3shared.SetHostIDMetadata(metadata, hostID) 9776 } 9777 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9778 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9779 } 9780 if len(errorComponents.Code) != 0 { 9781 errorCode = errorComponents.Code 9782 } 9783 if len(errorComponents.Message) != 0 { 9784 errorMessage = errorComponents.Message 9785 } 9786 errorBody.Seek(0, io.SeekStart) 9787 switch { 9788 default: 9789 genericError := &smithy.GenericAPIError{ 9790 Code: errorCode, 9791 Message: errorMessage, 9792 } 9793 return genericError 9794 9795 } 9796} 9797 9798type awsRestxml_deserializeOpPutBucketNotificationConfiguration struct { 9799} 9800 9801func (*awsRestxml_deserializeOpPutBucketNotificationConfiguration) ID() string { 9802 return "OperationDeserializer" 9803} 9804 9805func (m *awsRestxml_deserializeOpPutBucketNotificationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9806 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9807) { 9808 out, metadata, err = next.HandleDeserialize(ctx, in) 9809 if err != nil { 9810 return out, metadata, err 9811 } 9812 9813 response, ok := out.RawResponse.(*smithyhttp.Response) 9814 if !ok { 9815 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9816 } 9817 9818 if response.StatusCode < 200 || response.StatusCode >= 300 { 9819 return out, metadata, awsRestxml_deserializeOpErrorPutBucketNotificationConfiguration(response, &metadata) 9820 } 9821 output := &PutBucketNotificationConfigurationOutput{} 9822 out.Result = output 9823 9824 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9825 return out, metadata, &smithy.DeserializationError{ 9826 Err: fmt.Errorf("failed to discard response body, %w", err), 9827 } 9828 } 9829 9830 return out, metadata, err 9831} 9832 9833func awsRestxml_deserializeOpErrorPutBucketNotificationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9834 var errorBuffer bytes.Buffer 9835 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9836 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9837 } 9838 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9839 9840 errorCode := "UnknownError" 9841 errorMessage := errorCode 9842 9843 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9844 UseStatusCode: true, StatusCode: response.StatusCode, 9845 }) 9846 if err != nil { 9847 return err 9848 } 9849 if hostID := errorComponents.HostID; len(hostID) != 0 { 9850 s3shared.SetHostIDMetadata(metadata, hostID) 9851 } 9852 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9853 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9854 } 9855 if len(errorComponents.Code) != 0 { 9856 errorCode = errorComponents.Code 9857 } 9858 if len(errorComponents.Message) != 0 { 9859 errorMessage = errorComponents.Message 9860 } 9861 errorBody.Seek(0, io.SeekStart) 9862 switch { 9863 default: 9864 genericError := &smithy.GenericAPIError{ 9865 Code: errorCode, 9866 Message: errorMessage, 9867 } 9868 return genericError 9869 9870 } 9871} 9872 9873type awsRestxml_deserializeOpPutBucketOwnershipControls struct { 9874} 9875 9876func (*awsRestxml_deserializeOpPutBucketOwnershipControls) ID() string { 9877 return "OperationDeserializer" 9878} 9879 9880func (m *awsRestxml_deserializeOpPutBucketOwnershipControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9881 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9882) { 9883 out, metadata, err = next.HandleDeserialize(ctx, in) 9884 if err != nil { 9885 return out, metadata, err 9886 } 9887 9888 response, ok := out.RawResponse.(*smithyhttp.Response) 9889 if !ok { 9890 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9891 } 9892 9893 if response.StatusCode < 200 || response.StatusCode >= 300 { 9894 return out, metadata, awsRestxml_deserializeOpErrorPutBucketOwnershipControls(response, &metadata) 9895 } 9896 output := &PutBucketOwnershipControlsOutput{} 9897 out.Result = output 9898 9899 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9900 return out, metadata, &smithy.DeserializationError{ 9901 Err: fmt.Errorf("failed to discard response body, %w", err), 9902 } 9903 } 9904 9905 return out, metadata, err 9906} 9907 9908func awsRestxml_deserializeOpErrorPutBucketOwnershipControls(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9909 var errorBuffer bytes.Buffer 9910 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9911 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9912 } 9913 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9914 9915 errorCode := "UnknownError" 9916 errorMessage := errorCode 9917 9918 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9919 UseStatusCode: true, StatusCode: response.StatusCode, 9920 }) 9921 if err != nil { 9922 return err 9923 } 9924 if hostID := errorComponents.HostID; len(hostID) != 0 { 9925 s3shared.SetHostIDMetadata(metadata, hostID) 9926 } 9927 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9928 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9929 } 9930 if len(errorComponents.Code) != 0 { 9931 errorCode = errorComponents.Code 9932 } 9933 if len(errorComponents.Message) != 0 { 9934 errorMessage = errorComponents.Message 9935 } 9936 errorBody.Seek(0, io.SeekStart) 9937 switch { 9938 default: 9939 genericError := &smithy.GenericAPIError{ 9940 Code: errorCode, 9941 Message: errorMessage, 9942 } 9943 return genericError 9944 9945 } 9946} 9947 9948type awsRestxml_deserializeOpPutBucketPolicy struct { 9949} 9950 9951func (*awsRestxml_deserializeOpPutBucketPolicy) ID() string { 9952 return "OperationDeserializer" 9953} 9954 9955func (m *awsRestxml_deserializeOpPutBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9956 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9957) { 9958 out, metadata, err = next.HandleDeserialize(ctx, in) 9959 if err != nil { 9960 return out, metadata, err 9961 } 9962 9963 response, ok := out.RawResponse.(*smithyhttp.Response) 9964 if !ok { 9965 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9966 } 9967 9968 if response.StatusCode < 200 || response.StatusCode >= 300 { 9969 return out, metadata, awsRestxml_deserializeOpErrorPutBucketPolicy(response, &metadata) 9970 } 9971 output := &PutBucketPolicyOutput{} 9972 out.Result = output 9973 9974 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9975 return out, metadata, &smithy.DeserializationError{ 9976 Err: fmt.Errorf("failed to discard response body, %w", err), 9977 } 9978 } 9979 9980 return out, metadata, err 9981} 9982 9983func awsRestxml_deserializeOpErrorPutBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9984 var errorBuffer bytes.Buffer 9985 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9986 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9987 } 9988 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9989 9990 errorCode := "UnknownError" 9991 errorMessage := errorCode 9992 9993 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9994 UseStatusCode: true, StatusCode: response.StatusCode, 9995 }) 9996 if err != nil { 9997 return err 9998 } 9999 if hostID := errorComponents.HostID; len(hostID) != 0 { 10000 s3shared.SetHostIDMetadata(metadata, hostID) 10001 } 10002 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10003 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10004 } 10005 if len(errorComponents.Code) != 0 { 10006 errorCode = errorComponents.Code 10007 } 10008 if len(errorComponents.Message) != 0 { 10009 errorMessage = errorComponents.Message 10010 } 10011 errorBody.Seek(0, io.SeekStart) 10012 switch { 10013 default: 10014 genericError := &smithy.GenericAPIError{ 10015 Code: errorCode, 10016 Message: errorMessage, 10017 } 10018 return genericError 10019 10020 } 10021} 10022 10023type awsRestxml_deserializeOpPutBucketReplication struct { 10024} 10025 10026func (*awsRestxml_deserializeOpPutBucketReplication) ID() string { 10027 return "OperationDeserializer" 10028} 10029 10030func (m *awsRestxml_deserializeOpPutBucketReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10031 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10032) { 10033 out, metadata, err = next.HandleDeserialize(ctx, in) 10034 if err != nil { 10035 return out, metadata, err 10036 } 10037 10038 response, ok := out.RawResponse.(*smithyhttp.Response) 10039 if !ok { 10040 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10041 } 10042 10043 if response.StatusCode < 200 || response.StatusCode >= 300 { 10044 return out, metadata, awsRestxml_deserializeOpErrorPutBucketReplication(response, &metadata) 10045 } 10046 output := &PutBucketReplicationOutput{} 10047 out.Result = output 10048 10049 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10050 return out, metadata, &smithy.DeserializationError{ 10051 Err: fmt.Errorf("failed to discard response body, %w", err), 10052 } 10053 } 10054 10055 return out, metadata, err 10056} 10057 10058func awsRestxml_deserializeOpErrorPutBucketReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10059 var errorBuffer bytes.Buffer 10060 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10061 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10062 } 10063 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10064 10065 errorCode := "UnknownError" 10066 errorMessage := errorCode 10067 10068 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10069 UseStatusCode: true, StatusCode: response.StatusCode, 10070 }) 10071 if err != nil { 10072 return err 10073 } 10074 if hostID := errorComponents.HostID; len(hostID) != 0 { 10075 s3shared.SetHostIDMetadata(metadata, hostID) 10076 } 10077 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10078 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10079 } 10080 if len(errorComponents.Code) != 0 { 10081 errorCode = errorComponents.Code 10082 } 10083 if len(errorComponents.Message) != 0 { 10084 errorMessage = errorComponents.Message 10085 } 10086 errorBody.Seek(0, io.SeekStart) 10087 switch { 10088 default: 10089 genericError := &smithy.GenericAPIError{ 10090 Code: errorCode, 10091 Message: errorMessage, 10092 } 10093 return genericError 10094 10095 } 10096} 10097 10098type awsRestxml_deserializeOpPutBucketRequestPayment struct { 10099} 10100 10101func (*awsRestxml_deserializeOpPutBucketRequestPayment) ID() string { 10102 return "OperationDeserializer" 10103} 10104 10105func (m *awsRestxml_deserializeOpPutBucketRequestPayment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10106 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10107) { 10108 out, metadata, err = next.HandleDeserialize(ctx, in) 10109 if err != nil { 10110 return out, metadata, err 10111 } 10112 10113 response, ok := out.RawResponse.(*smithyhttp.Response) 10114 if !ok { 10115 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10116 } 10117 10118 if response.StatusCode < 200 || response.StatusCode >= 300 { 10119 return out, metadata, awsRestxml_deserializeOpErrorPutBucketRequestPayment(response, &metadata) 10120 } 10121 output := &PutBucketRequestPaymentOutput{} 10122 out.Result = output 10123 10124 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10125 return out, metadata, &smithy.DeserializationError{ 10126 Err: fmt.Errorf("failed to discard response body, %w", err), 10127 } 10128 } 10129 10130 return out, metadata, err 10131} 10132 10133func awsRestxml_deserializeOpErrorPutBucketRequestPayment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10134 var errorBuffer bytes.Buffer 10135 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10136 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10137 } 10138 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10139 10140 errorCode := "UnknownError" 10141 errorMessage := errorCode 10142 10143 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10144 UseStatusCode: true, StatusCode: response.StatusCode, 10145 }) 10146 if err != nil { 10147 return err 10148 } 10149 if hostID := errorComponents.HostID; len(hostID) != 0 { 10150 s3shared.SetHostIDMetadata(metadata, hostID) 10151 } 10152 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10153 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10154 } 10155 if len(errorComponents.Code) != 0 { 10156 errorCode = errorComponents.Code 10157 } 10158 if len(errorComponents.Message) != 0 { 10159 errorMessage = errorComponents.Message 10160 } 10161 errorBody.Seek(0, io.SeekStart) 10162 switch { 10163 default: 10164 genericError := &smithy.GenericAPIError{ 10165 Code: errorCode, 10166 Message: errorMessage, 10167 } 10168 return genericError 10169 10170 } 10171} 10172 10173type awsRestxml_deserializeOpPutBucketTagging struct { 10174} 10175 10176func (*awsRestxml_deserializeOpPutBucketTagging) ID() string { 10177 return "OperationDeserializer" 10178} 10179 10180func (m *awsRestxml_deserializeOpPutBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10181 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10182) { 10183 out, metadata, err = next.HandleDeserialize(ctx, in) 10184 if err != nil { 10185 return out, metadata, err 10186 } 10187 10188 response, ok := out.RawResponse.(*smithyhttp.Response) 10189 if !ok { 10190 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10191 } 10192 10193 if response.StatusCode < 200 || response.StatusCode >= 300 { 10194 return out, metadata, awsRestxml_deserializeOpErrorPutBucketTagging(response, &metadata) 10195 } 10196 output := &PutBucketTaggingOutput{} 10197 out.Result = output 10198 10199 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10200 return out, metadata, &smithy.DeserializationError{ 10201 Err: fmt.Errorf("failed to discard response body, %w", err), 10202 } 10203 } 10204 10205 return out, metadata, err 10206} 10207 10208func awsRestxml_deserializeOpErrorPutBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10209 var errorBuffer bytes.Buffer 10210 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10211 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10212 } 10213 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10214 10215 errorCode := "UnknownError" 10216 errorMessage := errorCode 10217 10218 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10219 UseStatusCode: true, StatusCode: response.StatusCode, 10220 }) 10221 if err != nil { 10222 return err 10223 } 10224 if hostID := errorComponents.HostID; len(hostID) != 0 { 10225 s3shared.SetHostIDMetadata(metadata, hostID) 10226 } 10227 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10228 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10229 } 10230 if len(errorComponents.Code) != 0 { 10231 errorCode = errorComponents.Code 10232 } 10233 if len(errorComponents.Message) != 0 { 10234 errorMessage = errorComponents.Message 10235 } 10236 errorBody.Seek(0, io.SeekStart) 10237 switch { 10238 default: 10239 genericError := &smithy.GenericAPIError{ 10240 Code: errorCode, 10241 Message: errorMessage, 10242 } 10243 return genericError 10244 10245 } 10246} 10247 10248type awsRestxml_deserializeOpPutBucketVersioning struct { 10249} 10250 10251func (*awsRestxml_deserializeOpPutBucketVersioning) ID() string { 10252 return "OperationDeserializer" 10253} 10254 10255func (m *awsRestxml_deserializeOpPutBucketVersioning) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10256 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10257) { 10258 out, metadata, err = next.HandleDeserialize(ctx, in) 10259 if err != nil { 10260 return out, metadata, err 10261 } 10262 10263 response, ok := out.RawResponse.(*smithyhttp.Response) 10264 if !ok { 10265 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10266 } 10267 10268 if response.StatusCode < 200 || response.StatusCode >= 300 { 10269 return out, metadata, awsRestxml_deserializeOpErrorPutBucketVersioning(response, &metadata) 10270 } 10271 output := &PutBucketVersioningOutput{} 10272 out.Result = output 10273 10274 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10275 return out, metadata, &smithy.DeserializationError{ 10276 Err: fmt.Errorf("failed to discard response body, %w", err), 10277 } 10278 } 10279 10280 return out, metadata, err 10281} 10282 10283func awsRestxml_deserializeOpErrorPutBucketVersioning(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10284 var errorBuffer bytes.Buffer 10285 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10286 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10287 } 10288 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10289 10290 errorCode := "UnknownError" 10291 errorMessage := errorCode 10292 10293 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10294 UseStatusCode: true, StatusCode: response.StatusCode, 10295 }) 10296 if err != nil { 10297 return err 10298 } 10299 if hostID := errorComponents.HostID; len(hostID) != 0 { 10300 s3shared.SetHostIDMetadata(metadata, hostID) 10301 } 10302 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10303 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10304 } 10305 if len(errorComponents.Code) != 0 { 10306 errorCode = errorComponents.Code 10307 } 10308 if len(errorComponents.Message) != 0 { 10309 errorMessage = errorComponents.Message 10310 } 10311 errorBody.Seek(0, io.SeekStart) 10312 switch { 10313 default: 10314 genericError := &smithy.GenericAPIError{ 10315 Code: errorCode, 10316 Message: errorMessage, 10317 } 10318 return genericError 10319 10320 } 10321} 10322 10323type awsRestxml_deserializeOpPutBucketWebsite struct { 10324} 10325 10326func (*awsRestxml_deserializeOpPutBucketWebsite) ID() string { 10327 return "OperationDeserializer" 10328} 10329 10330func (m *awsRestxml_deserializeOpPutBucketWebsite) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10331 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10332) { 10333 out, metadata, err = next.HandleDeserialize(ctx, in) 10334 if err != nil { 10335 return out, metadata, err 10336 } 10337 10338 response, ok := out.RawResponse.(*smithyhttp.Response) 10339 if !ok { 10340 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10341 } 10342 10343 if response.StatusCode < 200 || response.StatusCode >= 300 { 10344 return out, metadata, awsRestxml_deserializeOpErrorPutBucketWebsite(response, &metadata) 10345 } 10346 output := &PutBucketWebsiteOutput{} 10347 out.Result = output 10348 10349 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10350 return out, metadata, &smithy.DeserializationError{ 10351 Err: fmt.Errorf("failed to discard response body, %w", err), 10352 } 10353 } 10354 10355 return out, metadata, err 10356} 10357 10358func awsRestxml_deserializeOpErrorPutBucketWebsite(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10359 var errorBuffer bytes.Buffer 10360 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10361 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10362 } 10363 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10364 10365 errorCode := "UnknownError" 10366 errorMessage := errorCode 10367 10368 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10369 UseStatusCode: true, StatusCode: response.StatusCode, 10370 }) 10371 if err != nil { 10372 return err 10373 } 10374 if hostID := errorComponents.HostID; len(hostID) != 0 { 10375 s3shared.SetHostIDMetadata(metadata, hostID) 10376 } 10377 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10378 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10379 } 10380 if len(errorComponents.Code) != 0 { 10381 errorCode = errorComponents.Code 10382 } 10383 if len(errorComponents.Message) != 0 { 10384 errorMessage = errorComponents.Message 10385 } 10386 errorBody.Seek(0, io.SeekStart) 10387 switch { 10388 default: 10389 genericError := &smithy.GenericAPIError{ 10390 Code: errorCode, 10391 Message: errorMessage, 10392 } 10393 return genericError 10394 10395 } 10396} 10397 10398type awsRestxml_deserializeOpPutObject struct { 10399} 10400 10401func (*awsRestxml_deserializeOpPutObject) ID() string { 10402 return "OperationDeserializer" 10403} 10404 10405func (m *awsRestxml_deserializeOpPutObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10406 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10407) { 10408 out, metadata, err = next.HandleDeserialize(ctx, in) 10409 if err != nil { 10410 return out, metadata, err 10411 } 10412 10413 response, ok := out.RawResponse.(*smithyhttp.Response) 10414 if !ok { 10415 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10416 } 10417 10418 if response.StatusCode < 200 || response.StatusCode >= 300 { 10419 return out, metadata, awsRestxml_deserializeOpErrorPutObject(response, &metadata) 10420 } 10421 output := &PutObjectOutput{} 10422 out.Result = output 10423 10424 err = awsRestxml_deserializeOpHttpBindingsPutObjectOutput(output, response) 10425 if err != nil { 10426 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10427 } 10428 10429 return out, metadata, err 10430} 10431 10432func awsRestxml_deserializeOpErrorPutObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10433 var errorBuffer bytes.Buffer 10434 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10435 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10436 } 10437 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10438 10439 errorCode := "UnknownError" 10440 errorMessage := errorCode 10441 10442 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10443 UseStatusCode: true, StatusCode: response.StatusCode, 10444 }) 10445 if err != nil { 10446 return err 10447 } 10448 if hostID := errorComponents.HostID; len(hostID) != 0 { 10449 s3shared.SetHostIDMetadata(metadata, hostID) 10450 } 10451 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10452 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10453 } 10454 if len(errorComponents.Code) != 0 { 10455 errorCode = errorComponents.Code 10456 } 10457 if len(errorComponents.Message) != 0 { 10458 errorMessage = errorComponents.Message 10459 } 10460 errorBody.Seek(0, io.SeekStart) 10461 switch { 10462 default: 10463 genericError := &smithy.GenericAPIError{ 10464 Code: errorCode, 10465 Message: errorMessage, 10466 } 10467 return genericError 10468 10469 } 10470} 10471 10472func awsRestxml_deserializeOpHttpBindingsPutObjectOutput(v *PutObjectOutput, response *smithyhttp.Response) error { 10473 if v == nil { 10474 return fmt.Errorf("unsupported deserialization for nil %T", v) 10475 } 10476 10477 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 10478 headerValues[0] = strings.TrimSpace(headerValues[0]) 10479 vv, err := strconv.ParseBool(headerValues[0]) 10480 if err != nil { 10481 return err 10482 } 10483 v.BucketKeyEnabled = vv 10484 } 10485 10486 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 10487 headerValues[0] = strings.TrimSpace(headerValues[0]) 10488 v.ETag = ptr.String(headerValues[0]) 10489 } 10490 10491 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 10492 headerValues[0] = strings.TrimSpace(headerValues[0]) 10493 v.Expiration = ptr.String(headerValues[0]) 10494 } 10495 10496 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10497 headerValues[0] = strings.TrimSpace(headerValues[0]) 10498 v.RequestCharged = types.RequestCharged(headerValues[0]) 10499 } 10500 10501 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 10502 headerValues[0] = strings.TrimSpace(headerValues[0]) 10503 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 10504 } 10505 10506 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 10507 headerValues[0] = strings.TrimSpace(headerValues[0]) 10508 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 10509 } 10510 10511 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 10512 headerValues[0] = strings.TrimSpace(headerValues[0]) 10513 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 10514 } 10515 10516 if headerValues := response.Header.Values("x-amz-server-side-encryption-context"); len(headerValues) != 0 { 10517 headerValues[0] = strings.TrimSpace(headerValues[0]) 10518 v.SSEKMSEncryptionContext = ptr.String(headerValues[0]) 10519 } 10520 10521 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 10522 headerValues[0] = strings.TrimSpace(headerValues[0]) 10523 v.SSEKMSKeyId = ptr.String(headerValues[0]) 10524 } 10525 10526 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 10527 headerValues[0] = strings.TrimSpace(headerValues[0]) 10528 v.VersionId = ptr.String(headerValues[0]) 10529 } 10530 10531 return nil 10532} 10533 10534type awsRestxml_deserializeOpPutObjectAcl struct { 10535} 10536 10537func (*awsRestxml_deserializeOpPutObjectAcl) ID() string { 10538 return "OperationDeserializer" 10539} 10540 10541func (m *awsRestxml_deserializeOpPutObjectAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10542 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10543) { 10544 out, metadata, err = next.HandleDeserialize(ctx, in) 10545 if err != nil { 10546 return out, metadata, err 10547 } 10548 10549 response, ok := out.RawResponse.(*smithyhttp.Response) 10550 if !ok { 10551 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10552 } 10553 10554 if response.StatusCode < 200 || response.StatusCode >= 300 { 10555 return out, metadata, awsRestxml_deserializeOpErrorPutObjectAcl(response, &metadata) 10556 } 10557 output := &PutObjectAclOutput{} 10558 out.Result = output 10559 10560 err = awsRestxml_deserializeOpHttpBindingsPutObjectAclOutput(output, response) 10561 if err != nil { 10562 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10563 } 10564 10565 return out, metadata, err 10566} 10567 10568func awsRestxml_deserializeOpErrorPutObjectAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10569 var errorBuffer bytes.Buffer 10570 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10571 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10572 } 10573 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10574 10575 errorCode := "UnknownError" 10576 errorMessage := errorCode 10577 10578 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10579 UseStatusCode: true, StatusCode: response.StatusCode, 10580 }) 10581 if err != nil { 10582 return err 10583 } 10584 if hostID := errorComponents.HostID; len(hostID) != 0 { 10585 s3shared.SetHostIDMetadata(metadata, hostID) 10586 } 10587 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10588 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10589 } 10590 if len(errorComponents.Code) != 0 { 10591 errorCode = errorComponents.Code 10592 } 10593 if len(errorComponents.Message) != 0 { 10594 errorMessage = errorComponents.Message 10595 } 10596 errorBody.Seek(0, io.SeekStart) 10597 switch { 10598 case strings.EqualFold("NoSuchKey", errorCode): 10599 return awsRestxml_deserializeErrorNoSuchKey(response, errorBody) 10600 10601 default: 10602 genericError := &smithy.GenericAPIError{ 10603 Code: errorCode, 10604 Message: errorMessage, 10605 } 10606 return genericError 10607 10608 } 10609} 10610 10611func awsRestxml_deserializeOpHttpBindingsPutObjectAclOutput(v *PutObjectAclOutput, response *smithyhttp.Response) error { 10612 if v == nil { 10613 return fmt.Errorf("unsupported deserialization for nil %T", v) 10614 } 10615 10616 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10617 headerValues[0] = strings.TrimSpace(headerValues[0]) 10618 v.RequestCharged = types.RequestCharged(headerValues[0]) 10619 } 10620 10621 return nil 10622} 10623 10624type awsRestxml_deserializeOpPutObjectLegalHold struct { 10625} 10626 10627func (*awsRestxml_deserializeOpPutObjectLegalHold) ID() string { 10628 return "OperationDeserializer" 10629} 10630 10631func (m *awsRestxml_deserializeOpPutObjectLegalHold) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10632 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10633) { 10634 out, metadata, err = next.HandleDeserialize(ctx, in) 10635 if err != nil { 10636 return out, metadata, err 10637 } 10638 10639 response, ok := out.RawResponse.(*smithyhttp.Response) 10640 if !ok { 10641 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10642 } 10643 10644 if response.StatusCode < 200 || response.StatusCode >= 300 { 10645 return out, metadata, awsRestxml_deserializeOpErrorPutObjectLegalHold(response, &metadata) 10646 } 10647 output := &PutObjectLegalHoldOutput{} 10648 out.Result = output 10649 10650 err = awsRestxml_deserializeOpHttpBindingsPutObjectLegalHoldOutput(output, response) 10651 if err != nil { 10652 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10653 } 10654 10655 return out, metadata, err 10656} 10657 10658func awsRestxml_deserializeOpErrorPutObjectLegalHold(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10659 var errorBuffer bytes.Buffer 10660 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10661 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10662 } 10663 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10664 10665 errorCode := "UnknownError" 10666 errorMessage := errorCode 10667 10668 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10669 UseStatusCode: true, StatusCode: response.StatusCode, 10670 }) 10671 if err != nil { 10672 return err 10673 } 10674 if hostID := errorComponents.HostID; len(hostID) != 0 { 10675 s3shared.SetHostIDMetadata(metadata, hostID) 10676 } 10677 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10678 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10679 } 10680 if len(errorComponents.Code) != 0 { 10681 errorCode = errorComponents.Code 10682 } 10683 if len(errorComponents.Message) != 0 { 10684 errorMessage = errorComponents.Message 10685 } 10686 errorBody.Seek(0, io.SeekStart) 10687 switch { 10688 default: 10689 genericError := &smithy.GenericAPIError{ 10690 Code: errorCode, 10691 Message: errorMessage, 10692 } 10693 return genericError 10694 10695 } 10696} 10697 10698func awsRestxml_deserializeOpHttpBindingsPutObjectLegalHoldOutput(v *PutObjectLegalHoldOutput, response *smithyhttp.Response) error { 10699 if v == nil { 10700 return fmt.Errorf("unsupported deserialization for nil %T", v) 10701 } 10702 10703 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10704 headerValues[0] = strings.TrimSpace(headerValues[0]) 10705 v.RequestCharged = types.RequestCharged(headerValues[0]) 10706 } 10707 10708 return nil 10709} 10710 10711type awsRestxml_deserializeOpPutObjectLockConfiguration struct { 10712} 10713 10714func (*awsRestxml_deserializeOpPutObjectLockConfiguration) ID() string { 10715 return "OperationDeserializer" 10716} 10717 10718func (m *awsRestxml_deserializeOpPutObjectLockConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10719 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10720) { 10721 out, metadata, err = next.HandleDeserialize(ctx, in) 10722 if err != nil { 10723 return out, metadata, err 10724 } 10725 10726 response, ok := out.RawResponse.(*smithyhttp.Response) 10727 if !ok { 10728 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10729 } 10730 10731 if response.StatusCode < 200 || response.StatusCode >= 300 { 10732 return out, metadata, awsRestxml_deserializeOpErrorPutObjectLockConfiguration(response, &metadata) 10733 } 10734 output := &PutObjectLockConfigurationOutput{} 10735 out.Result = output 10736 10737 err = awsRestxml_deserializeOpHttpBindingsPutObjectLockConfigurationOutput(output, response) 10738 if err != nil { 10739 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10740 } 10741 10742 return out, metadata, err 10743} 10744 10745func awsRestxml_deserializeOpErrorPutObjectLockConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10746 var errorBuffer bytes.Buffer 10747 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10748 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10749 } 10750 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10751 10752 errorCode := "UnknownError" 10753 errorMessage := errorCode 10754 10755 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10756 UseStatusCode: true, StatusCode: response.StatusCode, 10757 }) 10758 if err != nil { 10759 return err 10760 } 10761 if hostID := errorComponents.HostID; len(hostID) != 0 { 10762 s3shared.SetHostIDMetadata(metadata, hostID) 10763 } 10764 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10765 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10766 } 10767 if len(errorComponents.Code) != 0 { 10768 errorCode = errorComponents.Code 10769 } 10770 if len(errorComponents.Message) != 0 { 10771 errorMessage = errorComponents.Message 10772 } 10773 errorBody.Seek(0, io.SeekStart) 10774 switch { 10775 default: 10776 genericError := &smithy.GenericAPIError{ 10777 Code: errorCode, 10778 Message: errorMessage, 10779 } 10780 return genericError 10781 10782 } 10783} 10784 10785func awsRestxml_deserializeOpHttpBindingsPutObjectLockConfigurationOutput(v *PutObjectLockConfigurationOutput, response *smithyhttp.Response) error { 10786 if v == nil { 10787 return fmt.Errorf("unsupported deserialization for nil %T", v) 10788 } 10789 10790 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10791 headerValues[0] = strings.TrimSpace(headerValues[0]) 10792 v.RequestCharged = types.RequestCharged(headerValues[0]) 10793 } 10794 10795 return nil 10796} 10797 10798type awsRestxml_deserializeOpPutObjectRetention struct { 10799} 10800 10801func (*awsRestxml_deserializeOpPutObjectRetention) ID() string { 10802 return "OperationDeserializer" 10803} 10804 10805func (m *awsRestxml_deserializeOpPutObjectRetention) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10806 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10807) { 10808 out, metadata, err = next.HandleDeserialize(ctx, in) 10809 if err != nil { 10810 return out, metadata, err 10811 } 10812 10813 response, ok := out.RawResponse.(*smithyhttp.Response) 10814 if !ok { 10815 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10816 } 10817 10818 if response.StatusCode < 200 || response.StatusCode >= 300 { 10819 return out, metadata, awsRestxml_deserializeOpErrorPutObjectRetention(response, &metadata) 10820 } 10821 output := &PutObjectRetentionOutput{} 10822 out.Result = output 10823 10824 err = awsRestxml_deserializeOpHttpBindingsPutObjectRetentionOutput(output, response) 10825 if err != nil { 10826 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10827 } 10828 10829 return out, metadata, err 10830} 10831 10832func awsRestxml_deserializeOpErrorPutObjectRetention(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10833 var errorBuffer bytes.Buffer 10834 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10835 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10836 } 10837 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10838 10839 errorCode := "UnknownError" 10840 errorMessage := errorCode 10841 10842 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10843 UseStatusCode: true, StatusCode: response.StatusCode, 10844 }) 10845 if err != nil { 10846 return err 10847 } 10848 if hostID := errorComponents.HostID; len(hostID) != 0 { 10849 s3shared.SetHostIDMetadata(metadata, hostID) 10850 } 10851 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10852 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10853 } 10854 if len(errorComponents.Code) != 0 { 10855 errorCode = errorComponents.Code 10856 } 10857 if len(errorComponents.Message) != 0 { 10858 errorMessage = errorComponents.Message 10859 } 10860 errorBody.Seek(0, io.SeekStart) 10861 switch { 10862 default: 10863 genericError := &smithy.GenericAPIError{ 10864 Code: errorCode, 10865 Message: errorMessage, 10866 } 10867 return genericError 10868 10869 } 10870} 10871 10872func awsRestxml_deserializeOpHttpBindingsPutObjectRetentionOutput(v *PutObjectRetentionOutput, response *smithyhttp.Response) error { 10873 if v == nil { 10874 return fmt.Errorf("unsupported deserialization for nil %T", v) 10875 } 10876 10877 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10878 headerValues[0] = strings.TrimSpace(headerValues[0]) 10879 v.RequestCharged = types.RequestCharged(headerValues[0]) 10880 } 10881 10882 return nil 10883} 10884 10885type awsRestxml_deserializeOpPutObjectTagging struct { 10886} 10887 10888func (*awsRestxml_deserializeOpPutObjectTagging) ID() string { 10889 return "OperationDeserializer" 10890} 10891 10892func (m *awsRestxml_deserializeOpPutObjectTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10893 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10894) { 10895 out, metadata, err = next.HandleDeserialize(ctx, in) 10896 if err != nil { 10897 return out, metadata, err 10898 } 10899 10900 response, ok := out.RawResponse.(*smithyhttp.Response) 10901 if !ok { 10902 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10903 } 10904 10905 if response.StatusCode < 200 || response.StatusCode >= 300 { 10906 return out, metadata, awsRestxml_deserializeOpErrorPutObjectTagging(response, &metadata) 10907 } 10908 output := &PutObjectTaggingOutput{} 10909 out.Result = output 10910 10911 err = awsRestxml_deserializeOpHttpBindingsPutObjectTaggingOutput(output, response) 10912 if err != nil { 10913 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10914 } 10915 10916 return out, metadata, err 10917} 10918 10919func awsRestxml_deserializeOpErrorPutObjectTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10920 var errorBuffer bytes.Buffer 10921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10923 } 10924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10925 10926 errorCode := "UnknownError" 10927 errorMessage := errorCode 10928 10929 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10930 UseStatusCode: true, StatusCode: response.StatusCode, 10931 }) 10932 if err != nil { 10933 return err 10934 } 10935 if hostID := errorComponents.HostID; len(hostID) != 0 { 10936 s3shared.SetHostIDMetadata(metadata, hostID) 10937 } 10938 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10939 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10940 } 10941 if len(errorComponents.Code) != 0 { 10942 errorCode = errorComponents.Code 10943 } 10944 if len(errorComponents.Message) != 0 { 10945 errorMessage = errorComponents.Message 10946 } 10947 errorBody.Seek(0, io.SeekStart) 10948 switch { 10949 default: 10950 genericError := &smithy.GenericAPIError{ 10951 Code: errorCode, 10952 Message: errorMessage, 10953 } 10954 return genericError 10955 10956 } 10957} 10958 10959func awsRestxml_deserializeOpHttpBindingsPutObjectTaggingOutput(v *PutObjectTaggingOutput, response *smithyhttp.Response) error { 10960 if v == nil { 10961 return fmt.Errorf("unsupported deserialization for nil %T", v) 10962 } 10963 10964 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 10965 headerValues[0] = strings.TrimSpace(headerValues[0]) 10966 v.VersionId = ptr.String(headerValues[0]) 10967 } 10968 10969 return nil 10970} 10971 10972type awsRestxml_deserializeOpPutPublicAccessBlock struct { 10973} 10974 10975func (*awsRestxml_deserializeOpPutPublicAccessBlock) ID() string { 10976 return "OperationDeserializer" 10977} 10978 10979func (m *awsRestxml_deserializeOpPutPublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10980 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10981) { 10982 out, metadata, err = next.HandleDeserialize(ctx, in) 10983 if err != nil { 10984 return out, metadata, err 10985 } 10986 10987 response, ok := out.RawResponse.(*smithyhttp.Response) 10988 if !ok { 10989 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10990 } 10991 10992 if response.StatusCode < 200 || response.StatusCode >= 300 { 10993 return out, metadata, awsRestxml_deserializeOpErrorPutPublicAccessBlock(response, &metadata) 10994 } 10995 output := &PutPublicAccessBlockOutput{} 10996 out.Result = output 10997 10998 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10999 return out, metadata, &smithy.DeserializationError{ 11000 Err: fmt.Errorf("failed to discard response body, %w", err), 11001 } 11002 } 11003 11004 return out, metadata, err 11005} 11006 11007func awsRestxml_deserializeOpErrorPutPublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11008 var errorBuffer bytes.Buffer 11009 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11010 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11011 } 11012 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11013 11014 errorCode := "UnknownError" 11015 errorMessage := errorCode 11016 11017 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11018 UseStatusCode: true, StatusCode: response.StatusCode, 11019 }) 11020 if err != nil { 11021 return err 11022 } 11023 if hostID := errorComponents.HostID; len(hostID) != 0 { 11024 s3shared.SetHostIDMetadata(metadata, hostID) 11025 } 11026 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11027 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11028 } 11029 if len(errorComponents.Code) != 0 { 11030 errorCode = errorComponents.Code 11031 } 11032 if len(errorComponents.Message) != 0 { 11033 errorMessage = errorComponents.Message 11034 } 11035 errorBody.Seek(0, io.SeekStart) 11036 switch { 11037 default: 11038 genericError := &smithy.GenericAPIError{ 11039 Code: errorCode, 11040 Message: errorMessage, 11041 } 11042 return genericError 11043 11044 } 11045} 11046 11047type awsRestxml_deserializeOpRestoreObject struct { 11048} 11049 11050func (*awsRestxml_deserializeOpRestoreObject) ID() string { 11051 return "OperationDeserializer" 11052} 11053 11054func (m *awsRestxml_deserializeOpRestoreObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11055 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11056) { 11057 out, metadata, err = next.HandleDeserialize(ctx, in) 11058 if err != nil { 11059 return out, metadata, err 11060 } 11061 11062 response, ok := out.RawResponse.(*smithyhttp.Response) 11063 if !ok { 11064 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11065 } 11066 11067 if response.StatusCode < 200 || response.StatusCode >= 300 { 11068 return out, metadata, awsRestxml_deserializeOpErrorRestoreObject(response, &metadata) 11069 } 11070 output := &RestoreObjectOutput{} 11071 out.Result = output 11072 11073 err = awsRestxml_deserializeOpHttpBindingsRestoreObjectOutput(output, response) 11074 if err != nil { 11075 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 11076 } 11077 11078 return out, metadata, err 11079} 11080 11081func awsRestxml_deserializeOpErrorRestoreObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11082 var errorBuffer bytes.Buffer 11083 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11084 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11085 } 11086 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11087 11088 errorCode := "UnknownError" 11089 errorMessage := errorCode 11090 11091 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11092 UseStatusCode: true, StatusCode: response.StatusCode, 11093 }) 11094 if err != nil { 11095 return err 11096 } 11097 if hostID := errorComponents.HostID; len(hostID) != 0 { 11098 s3shared.SetHostIDMetadata(metadata, hostID) 11099 } 11100 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11101 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11102 } 11103 if len(errorComponents.Code) != 0 { 11104 errorCode = errorComponents.Code 11105 } 11106 if len(errorComponents.Message) != 0 { 11107 errorMessage = errorComponents.Message 11108 } 11109 errorBody.Seek(0, io.SeekStart) 11110 switch { 11111 case strings.EqualFold("ObjectAlreadyInActiveTierError", errorCode): 11112 return awsRestxml_deserializeErrorObjectAlreadyInActiveTierError(response, errorBody) 11113 11114 default: 11115 genericError := &smithy.GenericAPIError{ 11116 Code: errorCode, 11117 Message: errorMessage, 11118 } 11119 return genericError 11120 11121 } 11122} 11123 11124func awsRestxml_deserializeOpHttpBindingsRestoreObjectOutput(v *RestoreObjectOutput, response *smithyhttp.Response) error { 11125 if v == nil { 11126 return fmt.Errorf("unsupported deserialization for nil %T", v) 11127 } 11128 11129 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 11130 headerValues[0] = strings.TrimSpace(headerValues[0]) 11131 v.RequestCharged = types.RequestCharged(headerValues[0]) 11132 } 11133 11134 if headerValues := response.Header.Values("x-amz-restore-output-path"); len(headerValues) != 0 { 11135 headerValues[0] = strings.TrimSpace(headerValues[0]) 11136 v.RestoreOutputPath = ptr.String(headerValues[0]) 11137 } 11138 11139 return nil 11140} 11141 11142type awsRestxml_deserializeOpUploadPart struct { 11143} 11144 11145func (*awsRestxml_deserializeOpUploadPart) ID() string { 11146 return "OperationDeserializer" 11147} 11148 11149func (m *awsRestxml_deserializeOpUploadPart) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11150 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11151) { 11152 out, metadata, err = next.HandleDeserialize(ctx, in) 11153 if err != nil { 11154 return out, metadata, err 11155 } 11156 11157 response, ok := out.RawResponse.(*smithyhttp.Response) 11158 if !ok { 11159 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11160 } 11161 11162 if response.StatusCode < 200 || response.StatusCode >= 300 { 11163 return out, metadata, awsRestxml_deserializeOpErrorUploadPart(response, &metadata) 11164 } 11165 output := &UploadPartOutput{} 11166 out.Result = output 11167 11168 err = awsRestxml_deserializeOpHttpBindingsUploadPartOutput(output, response) 11169 if err != nil { 11170 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 11171 } 11172 11173 return out, metadata, err 11174} 11175 11176func awsRestxml_deserializeOpErrorUploadPart(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11177 var errorBuffer bytes.Buffer 11178 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11179 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11180 } 11181 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11182 11183 errorCode := "UnknownError" 11184 errorMessage := errorCode 11185 11186 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11187 UseStatusCode: true, StatusCode: response.StatusCode, 11188 }) 11189 if err != nil { 11190 return err 11191 } 11192 if hostID := errorComponents.HostID; len(hostID) != 0 { 11193 s3shared.SetHostIDMetadata(metadata, hostID) 11194 } 11195 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11196 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11197 } 11198 if len(errorComponents.Code) != 0 { 11199 errorCode = errorComponents.Code 11200 } 11201 if len(errorComponents.Message) != 0 { 11202 errorMessage = errorComponents.Message 11203 } 11204 errorBody.Seek(0, io.SeekStart) 11205 switch { 11206 default: 11207 genericError := &smithy.GenericAPIError{ 11208 Code: errorCode, 11209 Message: errorMessage, 11210 } 11211 return genericError 11212 11213 } 11214} 11215 11216func awsRestxml_deserializeOpHttpBindingsUploadPartOutput(v *UploadPartOutput, response *smithyhttp.Response) error { 11217 if v == nil { 11218 return fmt.Errorf("unsupported deserialization for nil %T", v) 11219 } 11220 11221 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 11222 headerValues[0] = strings.TrimSpace(headerValues[0]) 11223 vv, err := strconv.ParseBool(headerValues[0]) 11224 if err != nil { 11225 return err 11226 } 11227 v.BucketKeyEnabled = vv 11228 } 11229 11230 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 11231 headerValues[0] = strings.TrimSpace(headerValues[0]) 11232 v.ETag = ptr.String(headerValues[0]) 11233 } 11234 11235 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 11236 headerValues[0] = strings.TrimSpace(headerValues[0]) 11237 v.RequestCharged = types.RequestCharged(headerValues[0]) 11238 } 11239 11240 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 11241 headerValues[0] = strings.TrimSpace(headerValues[0]) 11242 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 11243 } 11244 11245 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 11246 headerValues[0] = strings.TrimSpace(headerValues[0]) 11247 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 11248 } 11249 11250 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 11251 headerValues[0] = strings.TrimSpace(headerValues[0]) 11252 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 11253 } 11254 11255 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 11256 headerValues[0] = strings.TrimSpace(headerValues[0]) 11257 v.SSEKMSKeyId = ptr.String(headerValues[0]) 11258 } 11259 11260 return nil 11261} 11262 11263type awsRestxml_deserializeOpUploadPartCopy struct { 11264} 11265 11266func (*awsRestxml_deserializeOpUploadPartCopy) ID() string { 11267 return "OperationDeserializer" 11268} 11269 11270func (m *awsRestxml_deserializeOpUploadPartCopy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11271 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11272) { 11273 out, metadata, err = next.HandleDeserialize(ctx, in) 11274 if err != nil { 11275 return out, metadata, err 11276 } 11277 11278 response, ok := out.RawResponse.(*smithyhttp.Response) 11279 if !ok { 11280 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11281 } 11282 11283 if response.StatusCode < 200 || response.StatusCode >= 300 { 11284 return out, metadata, awsRestxml_deserializeOpErrorUploadPartCopy(response, &metadata) 11285 } 11286 output := &UploadPartCopyOutput{} 11287 out.Result = output 11288 11289 err = awsRestxml_deserializeOpHttpBindingsUploadPartCopyOutput(output, response) 11290 if err != nil { 11291 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 11292 } 11293 11294 var buff [1024]byte 11295 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11296 body := io.TeeReader(response.Body, ringBuffer) 11297 rootDecoder := xml.NewDecoder(body) 11298 t, err := smithyxml.FetchRootElement(rootDecoder) 11299 if err == io.EOF { 11300 return out, metadata, nil 11301 } 11302 if err != nil { 11303 var snapshot bytes.Buffer 11304 io.Copy(&snapshot, ringBuffer) 11305 return out, metadata, &smithy.DeserializationError{ 11306 Err: fmt.Errorf("failed to decode response body, %w", err), 11307 Snapshot: snapshot.Bytes(), 11308 } 11309 } 11310 11311 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11312 err = awsRestxml_deserializeDocumentCopyPartResult(&output.CopyPartResult, decoder) 11313 if err != nil { 11314 var snapshot bytes.Buffer 11315 io.Copy(&snapshot, ringBuffer) 11316 return out, metadata, &smithy.DeserializationError{ 11317 Err: fmt.Errorf("failed to decode response body, %w", err), 11318 Snapshot: snapshot.Bytes(), 11319 } 11320 } 11321 11322 return out, metadata, err 11323} 11324 11325func awsRestxml_deserializeOpErrorUploadPartCopy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11326 var errorBuffer bytes.Buffer 11327 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11328 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11329 } 11330 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11331 11332 errorCode := "UnknownError" 11333 errorMessage := errorCode 11334 11335 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11336 UseStatusCode: true, StatusCode: response.StatusCode, 11337 }) 11338 if err != nil { 11339 return err 11340 } 11341 if hostID := errorComponents.HostID; len(hostID) != 0 { 11342 s3shared.SetHostIDMetadata(metadata, hostID) 11343 } 11344 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11345 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11346 } 11347 if len(errorComponents.Code) != 0 { 11348 errorCode = errorComponents.Code 11349 } 11350 if len(errorComponents.Message) != 0 { 11351 errorMessage = errorComponents.Message 11352 } 11353 errorBody.Seek(0, io.SeekStart) 11354 switch { 11355 default: 11356 genericError := &smithy.GenericAPIError{ 11357 Code: errorCode, 11358 Message: errorMessage, 11359 } 11360 return genericError 11361 11362 } 11363} 11364 11365func awsRestxml_deserializeOpHttpBindingsUploadPartCopyOutput(v *UploadPartCopyOutput, response *smithyhttp.Response) error { 11366 if v == nil { 11367 return fmt.Errorf("unsupported deserialization for nil %T", v) 11368 } 11369 11370 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 11371 headerValues[0] = strings.TrimSpace(headerValues[0]) 11372 vv, err := strconv.ParseBool(headerValues[0]) 11373 if err != nil { 11374 return err 11375 } 11376 v.BucketKeyEnabled = vv 11377 } 11378 11379 if headerValues := response.Header.Values("x-amz-copy-source-version-id"); len(headerValues) != 0 { 11380 headerValues[0] = strings.TrimSpace(headerValues[0]) 11381 v.CopySourceVersionId = ptr.String(headerValues[0]) 11382 } 11383 11384 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 11385 headerValues[0] = strings.TrimSpace(headerValues[0]) 11386 v.RequestCharged = types.RequestCharged(headerValues[0]) 11387 } 11388 11389 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 11390 headerValues[0] = strings.TrimSpace(headerValues[0]) 11391 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 11392 } 11393 11394 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 11395 headerValues[0] = strings.TrimSpace(headerValues[0]) 11396 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 11397 } 11398 11399 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 11400 headerValues[0] = strings.TrimSpace(headerValues[0]) 11401 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 11402 } 11403 11404 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 11405 headerValues[0] = strings.TrimSpace(headerValues[0]) 11406 v.SSEKMSKeyId = ptr.String(headerValues[0]) 11407 } 11408 11409 return nil 11410} 11411func awsRestxml_deserializeOpDocumentUploadPartCopyOutput(v **UploadPartCopyOutput, decoder smithyxml.NodeDecoder) error { 11412 if v == nil { 11413 return fmt.Errorf("unexpected nil of type %T", v) 11414 } 11415 var sv *UploadPartCopyOutput 11416 if *v == nil { 11417 sv = &UploadPartCopyOutput{} 11418 } else { 11419 sv = *v 11420 } 11421 11422 for { 11423 t, done, err := decoder.Token() 11424 if err != nil { 11425 return err 11426 } 11427 if done { 11428 break 11429 } 11430 originalDecoder := decoder 11431 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11432 switch { 11433 case strings.EqualFold("CopyPartResult", t.Name.Local): 11434 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11435 if err := awsRestxml_deserializeDocumentCopyPartResult(&sv.CopyPartResult, nodeDecoder); err != nil { 11436 return err 11437 } 11438 11439 default: 11440 // Do nothing and ignore the unexpected tag element 11441 err = decoder.Decoder.Skip() 11442 if err != nil { 11443 return err 11444 } 11445 11446 } 11447 decoder = originalDecoder 11448 } 11449 *v = sv 11450 return nil 11451} 11452 11453func awsRestxml_deserializeErrorBucketAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11454 output := &types.BucketAlreadyExists{} 11455 return output 11456} 11457 11458func awsRestxml_deserializeErrorBucketAlreadyOwnedByYou(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11459 output := &types.BucketAlreadyOwnedByYou{} 11460 return output 11461} 11462 11463func awsRestxml_deserializeErrorInvalidObjectState(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11464 output := &types.InvalidObjectState{} 11465 var buff [1024]byte 11466 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11467 body := io.TeeReader(errorBody, ringBuffer) 11468 rootDecoder := xml.NewDecoder(body) 11469 t, err := smithyxml.FetchRootElement(rootDecoder) 11470 if err == io.EOF { 11471 return output 11472 } 11473 if err != nil { 11474 var snapshot bytes.Buffer 11475 io.Copy(&snapshot, ringBuffer) 11476 return &smithy.DeserializationError{ 11477 Err: fmt.Errorf("failed to decode response body, %w", err), 11478 Snapshot: snapshot.Bytes(), 11479 } 11480 } 11481 11482 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11483 err = awsRestxml_deserializeDocumentInvalidObjectState(&output, decoder) 11484 if err != nil { 11485 var snapshot bytes.Buffer 11486 io.Copy(&snapshot, ringBuffer) 11487 return &smithy.DeserializationError{ 11488 Err: fmt.Errorf("failed to decode response body, %w", err), 11489 Snapshot: snapshot.Bytes(), 11490 } 11491 } 11492 11493 return output 11494} 11495 11496func awsRestxml_deserializeErrorNoSuchBucket(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11497 output := &types.NoSuchBucket{} 11498 return output 11499} 11500 11501func awsRestxml_deserializeErrorNoSuchKey(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11502 output := &types.NoSuchKey{} 11503 return output 11504} 11505 11506func awsRestxml_deserializeErrorNoSuchUpload(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11507 output := &types.NoSuchUpload{} 11508 return output 11509} 11510 11511func awsRestxml_deserializeErrorNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11512 output := &types.NotFound{} 11513 return output 11514} 11515 11516func awsRestxml_deserializeErrorObjectAlreadyInActiveTierError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11517 output := &types.ObjectAlreadyInActiveTierError{} 11518 return output 11519} 11520 11521func awsRestxml_deserializeErrorObjectNotInActiveTierError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11522 output := &types.ObjectNotInActiveTierError{} 11523 return output 11524} 11525 11526func awsRestxml_deserializeDocumentAbortIncompleteMultipartUpload(v **types.AbortIncompleteMultipartUpload, decoder smithyxml.NodeDecoder) error { 11527 if v == nil { 11528 return fmt.Errorf("unexpected nil of type %T", v) 11529 } 11530 var sv *types.AbortIncompleteMultipartUpload 11531 if *v == nil { 11532 sv = &types.AbortIncompleteMultipartUpload{} 11533 } else { 11534 sv = *v 11535 } 11536 11537 for { 11538 t, done, err := decoder.Token() 11539 if err != nil { 11540 return err 11541 } 11542 if done { 11543 break 11544 } 11545 originalDecoder := decoder 11546 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11547 switch { 11548 case strings.EqualFold("DaysAfterInitiation", t.Name.Local): 11549 val, err := decoder.Value() 11550 if err != nil { 11551 return err 11552 } 11553 if val == nil { 11554 break 11555 } 11556 { 11557 xtv := string(val) 11558 i64, err := strconv.ParseInt(xtv, 10, 64) 11559 if err != nil { 11560 return err 11561 } 11562 sv.DaysAfterInitiation = int32(i64) 11563 } 11564 11565 default: 11566 // Do nothing and ignore the unexpected tag element 11567 err = decoder.Decoder.Skip() 11568 if err != nil { 11569 return err 11570 } 11571 11572 } 11573 decoder = originalDecoder 11574 } 11575 *v = sv 11576 return nil 11577} 11578 11579func awsRestxml_deserializeDocumentAccessControlTranslation(v **types.AccessControlTranslation, decoder smithyxml.NodeDecoder) error { 11580 if v == nil { 11581 return fmt.Errorf("unexpected nil of type %T", v) 11582 } 11583 var sv *types.AccessControlTranslation 11584 if *v == nil { 11585 sv = &types.AccessControlTranslation{} 11586 } else { 11587 sv = *v 11588 } 11589 11590 for { 11591 t, done, err := decoder.Token() 11592 if err != nil { 11593 return err 11594 } 11595 if done { 11596 break 11597 } 11598 originalDecoder := decoder 11599 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11600 switch { 11601 case strings.EqualFold("Owner", t.Name.Local): 11602 val, err := decoder.Value() 11603 if err != nil { 11604 return err 11605 } 11606 if val == nil { 11607 break 11608 } 11609 { 11610 xtv := string(val) 11611 sv.Owner = types.OwnerOverride(xtv) 11612 } 11613 11614 default: 11615 // Do nothing and ignore the unexpected tag element 11616 err = decoder.Decoder.Skip() 11617 if err != nil { 11618 return err 11619 } 11620 11621 } 11622 decoder = originalDecoder 11623 } 11624 *v = sv 11625 return nil 11626} 11627 11628func awsRestxml_deserializeDocumentAllowedHeaders(v *[]string, decoder smithyxml.NodeDecoder) error { 11629 if v == nil { 11630 return fmt.Errorf("unexpected nil of type %T", v) 11631 } 11632 var sv []string 11633 if *v == nil { 11634 sv = make([]string, 0) 11635 } else { 11636 sv = *v 11637 } 11638 11639 originalDecoder := decoder 11640 for { 11641 t, done, err := decoder.Token() 11642 if err != nil { 11643 return err 11644 } 11645 if done { 11646 break 11647 } 11648 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11649 decoder = memberDecoder 11650 switch { 11651 case strings.EqualFold("member", t.Name.Local): 11652 var col string 11653 val, err := decoder.Value() 11654 if err != nil { 11655 return err 11656 } 11657 if val == nil { 11658 break 11659 } 11660 { 11661 xtv := string(val) 11662 col = xtv 11663 } 11664 sv = append(sv, col) 11665 11666 default: 11667 err = decoder.Decoder.Skip() 11668 if err != nil { 11669 return err 11670 } 11671 11672 } 11673 decoder = originalDecoder 11674 } 11675 *v = sv 11676 return nil 11677} 11678 11679func awsRestxml_deserializeDocumentAllowedHeadersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 11680 var sv []string 11681 if *v == nil { 11682 sv = make([]string, 0) 11683 } else { 11684 sv = *v 11685 } 11686 11687 switch { 11688 default: 11689 var mv string 11690 t := decoder.StartEl 11691 _ = t 11692 val, err := decoder.Value() 11693 if err != nil { 11694 return err 11695 } 11696 if val == nil { 11697 break 11698 } 11699 { 11700 xtv := string(val) 11701 mv = xtv 11702 } 11703 sv = append(sv, mv) 11704 } 11705 *v = sv 11706 return nil 11707} 11708func awsRestxml_deserializeDocumentAllowedMethods(v *[]string, decoder smithyxml.NodeDecoder) error { 11709 if v == nil { 11710 return fmt.Errorf("unexpected nil of type %T", v) 11711 } 11712 var sv []string 11713 if *v == nil { 11714 sv = make([]string, 0) 11715 } else { 11716 sv = *v 11717 } 11718 11719 originalDecoder := decoder 11720 for { 11721 t, done, err := decoder.Token() 11722 if err != nil { 11723 return err 11724 } 11725 if done { 11726 break 11727 } 11728 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11729 decoder = memberDecoder 11730 switch { 11731 case strings.EqualFold("member", t.Name.Local): 11732 var col string 11733 val, err := decoder.Value() 11734 if err != nil { 11735 return err 11736 } 11737 if val == nil { 11738 break 11739 } 11740 { 11741 xtv := string(val) 11742 col = xtv 11743 } 11744 sv = append(sv, col) 11745 11746 default: 11747 err = decoder.Decoder.Skip() 11748 if err != nil { 11749 return err 11750 } 11751 11752 } 11753 decoder = originalDecoder 11754 } 11755 *v = sv 11756 return nil 11757} 11758 11759func awsRestxml_deserializeDocumentAllowedMethodsUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 11760 var sv []string 11761 if *v == nil { 11762 sv = make([]string, 0) 11763 } else { 11764 sv = *v 11765 } 11766 11767 switch { 11768 default: 11769 var mv string 11770 t := decoder.StartEl 11771 _ = t 11772 val, err := decoder.Value() 11773 if err != nil { 11774 return err 11775 } 11776 if val == nil { 11777 break 11778 } 11779 { 11780 xtv := string(val) 11781 mv = xtv 11782 } 11783 sv = append(sv, mv) 11784 } 11785 *v = sv 11786 return nil 11787} 11788func awsRestxml_deserializeDocumentAllowedOrigins(v *[]string, decoder smithyxml.NodeDecoder) error { 11789 if v == nil { 11790 return fmt.Errorf("unexpected nil of type %T", v) 11791 } 11792 var sv []string 11793 if *v == nil { 11794 sv = make([]string, 0) 11795 } else { 11796 sv = *v 11797 } 11798 11799 originalDecoder := decoder 11800 for { 11801 t, done, err := decoder.Token() 11802 if err != nil { 11803 return err 11804 } 11805 if done { 11806 break 11807 } 11808 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11809 decoder = memberDecoder 11810 switch { 11811 case strings.EqualFold("member", t.Name.Local): 11812 var col string 11813 val, err := decoder.Value() 11814 if err != nil { 11815 return err 11816 } 11817 if val == nil { 11818 break 11819 } 11820 { 11821 xtv := string(val) 11822 col = xtv 11823 } 11824 sv = append(sv, col) 11825 11826 default: 11827 err = decoder.Decoder.Skip() 11828 if err != nil { 11829 return err 11830 } 11831 11832 } 11833 decoder = originalDecoder 11834 } 11835 *v = sv 11836 return nil 11837} 11838 11839func awsRestxml_deserializeDocumentAllowedOriginsUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 11840 var sv []string 11841 if *v == nil { 11842 sv = make([]string, 0) 11843 } else { 11844 sv = *v 11845 } 11846 11847 switch { 11848 default: 11849 var mv string 11850 t := decoder.StartEl 11851 _ = t 11852 val, err := decoder.Value() 11853 if err != nil { 11854 return err 11855 } 11856 if val == nil { 11857 break 11858 } 11859 { 11860 xtv := string(val) 11861 mv = xtv 11862 } 11863 sv = append(sv, mv) 11864 } 11865 *v = sv 11866 return nil 11867} 11868func awsRestxml_deserializeDocumentAnalyticsAndOperator(v **types.AnalyticsAndOperator, decoder smithyxml.NodeDecoder) error { 11869 if v == nil { 11870 return fmt.Errorf("unexpected nil of type %T", v) 11871 } 11872 var sv *types.AnalyticsAndOperator 11873 if *v == nil { 11874 sv = &types.AnalyticsAndOperator{} 11875 } else { 11876 sv = *v 11877 } 11878 11879 for { 11880 t, done, err := decoder.Token() 11881 if err != nil { 11882 return err 11883 } 11884 if done { 11885 break 11886 } 11887 originalDecoder := decoder 11888 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11889 switch { 11890 case strings.EqualFold("Prefix", t.Name.Local): 11891 val, err := decoder.Value() 11892 if err != nil { 11893 return err 11894 } 11895 if val == nil { 11896 break 11897 } 11898 { 11899 xtv := string(val) 11900 sv.Prefix = ptr.String(xtv) 11901 } 11902 11903 case strings.EqualFold("Tag", t.Name.Local): 11904 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11905 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 11906 return err 11907 } 11908 11909 default: 11910 // Do nothing and ignore the unexpected tag element 11911 err = decoder.Decoder.Skip() 11912 if err != nil { 11913 return err 11914 } 11915 11916 } 11917 decoder = originalDecoder 11918 } 11919 *v = sv 11920 return nil 11921} 11922 11923func awsRestxml_deserializeDocumentAnalyticsConfiguration(v **types.AnalyticsConfiguration, decoder smithyxml.NodeDecoder) error { 11924 if v == nil { 11925 return fmt.Errorf("unexpected nil of type %T", v) 11926 } 11927 var sv *types.AnalyticsConfiguration 11928 if *v == nil { 11929 sv = &types.AnalyticsConfiguration{} 11930 } else { 11931 sv = *v 11932 } 11933 11934 for { 11935 t, done, err := decoder.Token() 11936 if err != nil { 11937 return err 11938 } 11939 if done { 11940 break 11941 } 11942 originalDecoder := decoder 11943 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11944 switch { 11945 case strings.EqualFold("Filter", t.Name.Local): 11946 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11947 if err := awsRestxml_deserializeDocumentAnalyticsFilter(&sv.Filter, nodeDecoder); err != nil { 11948 return err 11949 } 11950 11951 case strings.EqualFold("Id", t.Name.Local): 11952 val, err := decoder.Value() 11953 if err != nil { 11954 return err 11955 } 11956 if val == nil { 11957 break 11958 } 11959 { 11960 xtv := string(val) 11961 sv.Id = ptr.String(xtv) 11962 } 11963 11964 case strings.EqualFold("StorageClassAnalysis", t.Name.Local): 11965 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11966 if err := awsRestxml_deserializeDocumentStorageClassAnalysis(&sv.StorageClassAnalysis, nodeDecoder); err != nil { 11967 return err 11968 } 11969 11970 default: 11971 // Do nothing and ignore the unexpected tag element 11972 err = decoder.Decoder.Skip() 11973 if err != nil { 11974 return err 11975 } 11976 11977 } 11978 decoder = originalDecoder 11979 } 11980 *v = sv 11981 return nil 11982} 11983 11984func awsRestxml_deserializeDocumentAnalyticsConfigurationList(v *[]types.AnalyticsConfiguration, decoder smithyxml.NodeDecoder) error { 11985 if v == nil { 11986 return fmt.Errorf("unexpected nil of type %T", v) 11987 } 11988 var sv []types.AnalyticsConfiguration 11989 if *v == nil { 11990 sv = make([]types.AnalyticsConfiguration, 0) 11991 } else { 11992 sv = *v 11993 } 11994 11995 originalDecoder := decoder 11996 for { 11997 t, done, err := decoder.Token() 11998 if err != nil { 11999 return err 12000 } 12001 if done { 12002 break 12003 } 12004 switch { 12005 case strings.EqualFold("member", t.Name.Local): 12006 var col types.AnalyticsConfiguration 12007 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12008 destAddr := &col 12009 if err := awsRestxml_deserializeDocumentAnalyticsConfiguration(&destAddr, nodeDecoder); err != nil { 12010 return err 12011 } 12012 col = *destAddr 12013 sv = append(sv, col) 12014 12015 default: 12016 err = decoder.Decoder.Skip() 12017 if err != nil { 12018 return err 12019 } 12020 12021 } 12022 decoder = originalDecoder 12023 } 12024 *v = sv 12025 return nil 12026} 12027 12028func awsRestxml_deserializeDocumentAnalyticsConfigurationListUnwrapped(v *[]types.AnalyticsConfiguration, decoder smithyxml.NodeDecoder) error { 12029 var sv []types.AnalyticsConfiguration 12030 if *v == nil { 12031 sv = make([]types.AnalyticsConfiguration, 0) 12032 } else { 12033 sv = *v 12034 } 12035 12036 switch { 12037 default: 12038 var mv types.AnalyticsConfiguration 12039 t := decoder.StartEl 12040 _ = t 12041 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12042 destAddr := &mv 12043 if err := awsRestxml_deserializeDocumentAnalyticsConfiguration(&destAddr, nodeDecoder); err != nil { 12044 return err 12045 } 12046 mv = *destAddr 12047 sv = append(sv, mv) 12048 } 12049 *v = sv 12050 return nil 12051} 12052func awsRestxml_deserializeDocumentAnalyticsExportDestination(v **types.AnalyticsExportDestination, decoder smithyxml.NodeDecoder) error { 12053 if v == nil { 12054 return fmt.Errorf("unexpected nil of type %T", v) 12055 } 12056 var sv *types.AnalyticsExportDestination 12057 if *v == nil { 12058 sv = &types.AnalyticsExportDestination{} 12059 } else { 12060 sv = *v 12061 } 12062 12063 for { 12064 t, done, err := decoder.Token() 12065 if err != nil { 12066 return err 12067 } 12068 if done { 12069 break 12070 } 12071 originalDecoder := decoder 12072 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12073 switch { 12074 case strings.EqualFold("S3BucketDestination", t.Name.Local): 12075 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12076 if err := awsRestxml_deserializeDocumentAnalyticsS3BucketDestination(&sv.S3BucketDestination, nodeDecoder); err != nil { 12077 return err 12078 } 12079 12080 default: 12081 // Do nothing and ignore the unexpected tag element 12082 err = decoder.Decoder.Skip() 12083 if err != nil { 12084 return err 12085 } 12086 12087 } 12088 decoder = originalDecoder 12089 } 12090 *v = sv 12091 return nil 12092} 12093 12094func awsRestxml_deserializeDocumentAnalyticsFilter(v *types.AnalyticsFilter, decoder smithyxml.NodeDecoder) error { 12095 if v == nil { 12096 return fmt.Errorf("unexpected nil of type %T", v) 12097 } 12098 var uv types.AnalyticsFilter 12099 var memberFound bool 12100 for { 12101 t, done, err := decoder.Token() 12102 if err != nil { 12103 return err 12104 } 12105 if done { 12106 break 12107 } 12108 if memberFound { 12109 if err = decoder.Decoder.Skip(); err != nil { 12110 return err 12111 } 12112 } 12113 originalDecoder := decoder 12114 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12115 switch { 12116 case strings.EqualFold("And", t.Name.Local): 12117 var mv types.AnalyticsAndOperator 12118 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12119 destAddr := &mv 12120 if err := awsRestxml_deserializeDocumentAnalyticsAndOperator(&destAddr, nodeDecoder); err != nil { 12121 return err 12122 } 12123 mv = *destAddr 12124 uv = &types.AnalyticsFilterMemberAnd{Value: mv} 12125 memberFound = true 12126 12127 case strings.EqualFold("Prefix", t.Name.Local): 12128 var mv string 12129 val, err := decoder.Value() 12130 if err != nil { 12131 return err 12132 } 12133 if val == nil { 12134 break 12135 } 12136 { 12137 xtv := string(val) 12138 mv = xtv 12139 } 12140 uv = &types.AnalyticsFilterMemberPrefix{Value: mv} 12141 memberFound = true 12142 12143 case strings.EqualFold("Tag", t.Name.Local): 12144 var mv types.Tag 12145 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12146 destAddr := &mv 12147 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 12148 return err 12149 } 12150 mv = *destAddr 12151 uv = &types.AnalyticsFilterMemberTag{Value: mv} 12152 memberFound = true 12153 12154 default: 12155 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 12156 memberFound = true 12157 12158 } 12159 decoder = originalDecoder 12160 } 12161 *v = uv 12162 return nil 12163} 12164 12165func awsRestxml_deserializeDocumentAnalyticsS3BucketDestination(v **types.AnalyticsS3BucketDestination, decoder smithyxml.NodeDecoder) error { 12166 if v == nil { 12167 return fmt.Errorf("unexpected nil of type %T", v) 12168 } 12169 var sv *types.AnalyticsS3BucketDestination 12170 if *v == nil { 12171 sv = &types.AnalyticsS3BucketDestination{} 12172 } else { 12173 sv = *v 12174 } 12175 12176 for { 12177 t, done, err := decoder.Token() 12178 if err != nil { 12179 return err 12180 } 12181 if done { 12182 break 12183 } 12184 originalDecoder := decoder 12185 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12186 switch { 12187 case strings.EqualFold("Bucket", t.Name.Local): 12188 val, err := decoder.Value() 12189 if err != nil { 12190 return err 12191 } 12192 if val == nil { 12193 break 12194 } 12195 { 12196 xtv := string(val) 12197 sv.Bucket = ptr.String(xtv) 12198 } 12199 12200 case strings.EqualFold("BucketAccountId", t.Name.Local): 12201 val, err := decoder.Value() 12202 if err != nil { 12203 return err 12204 } 12205 if val == nil { 12206 break 12207 } 12208 { 12209 xtv := string(val) 12210 sv.BucketAccountId = ptr.String(xtv) 12211 } 12212 12213 case strings.EqualFold("Format", t.Name.Local): 12214 val, err := decoder.Value() 12215 if err != nil { 12216 return err 12217 } 12218 if val == nil { 12219 break 12220 } 12221 { 12222 xtv := string(val) 12223 sv.Format = types.AnalyticsS3ExportFileFormat(xtv) 12224 } 12225 12226 case strings.EqualFold("Prefix", t.Name.Local): 12227 val, err := decoder.Value() 12228 if err != nil { 12229 return err 12230 } 12231 if val == nil { 12232 break 12233 } 12234 { 12235 xtv := string(val) 12236 sv.Prefix = ptr.String(xtv) 12237 } 12238 12239 default: 12240 // Do nothing and ignore the unexpected tag element 12241 err = decoder.Decoder.Skip() 12242 if err != nil { 12243 return err 12244 } 12245 12246 } 12247 decoder = originalDecoder 12248 } 12249 *v = sv 12250 return nil 12251} 12252 12253func awsRestxml_deserializeDocumentBucket(v **types.Bucket, decoder smithyxml.NodeDecoder) error { 12254 if v == nil { 12255 return fmt.Errorf("unexpected nil of type %T", v) 12256 } 12257 var sv *types.Bucket 12258 if *v == nil { 12259 sv = &types.Bucket{} 12260 } else { 12261 sv = *v 12262 } 12263 12264 for { 12265 t, done, err := decoder.Token() 12266 if err != nil { 12267 return err 12268 } 12269 if done { 12270 break 12271 } 12272 originalDecoder := decoder 12273 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12274 switch { 12275 case strings.EqualFold("CreationDate", t.Name.Local): 12276 val, err := decoder.Value() 12277 if err != nil { 12278 return err 12279 } 12280 if val == nil { 12281 break 12282 } 12283 { 12284 xtv := string(val) 12285 t, err := smithytime.ParseDateTime(xtv) 12286 if err != nil { 12287 return err 12288 } 12289 sv.CreationDate = ptr.Time(t) 12290 } 12291 12292 case strings.EqualFold("Name", t.Name.Local): 12293 val, err := decoder.Value() 12294 if err != nil { 12295 return err 12296 } 12297 if val == nil { 12298 break 12299 } 12300 { 12301 xtv := string(val) 12302 sv.Name = ptr.String(xtv) 12303 } 12304 12305 default: 12306 // Do nothing and ignore the unexpected tag element 12307 err = decoder.Decoder.Skip() 12308 if err != nil { 12309 return err 12310 } 12311 12312 } 12313 decoder = originalDecoder 12314 } 12315 *v = sv 12316 return nil 12317} 12318 12319func awsRestxml_deserializeDocumentBucketAlreadyExists(v **types.BucketAlreadyExists, decoder smithyxml.NodeDecoder) error { 12320 if v == nil { 12321 return fmt.Errorf("unexpected nil of type %T", v) 12322 } 12323 var sv *types.BucketAlreadyExists 12324 if *v == nil { 12325 sv = &types.BucketAlreadyExists{} 12326 } else { 12327 sv = *v 12328 } 12329 12330 for { 12331 t, done, err := decoder.Token() 12332 if err != nil { 12333 return err 12334 } 12335 if done { 12336 break 12337 } 12338 originalDecoder := decoder 12339 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12340 switch { 12341 default: 12342 // Do nothing and ignore the unexpected tag element 12343 err = decoder.Decoder.Skip() 12344 if err != nil { 12345 return err 12346 } 12347 12348 } 12349 decoder = originalDecoder 12350 } 12351 *v = sv 12352 return nil 12353} 12354 12355func awsRestxml_deserializeDocumentBucketAlreadyOwnedByYou(v **types.BucketAlreadyOwnedByYou, decoder smithyxml.NodeDecoder) error { 12356 if v == nil { 12357 return fmt.Errorf("unexpected nil of type %T", v) 12358 } 12359 var sv *types.BucketAlreadyOwnedByYou 12360 if *v == nil { 12361 sv = &types.BucketAlreadyOwnedByYou{} 12362 } else { 12363 sv = *v 12364 } 12365 12366 for { 12367 t, done, err := decoder.Token() 12368 if err != nil { 12369 return err 12370 } 12371 if done { 12372 break 12373 } 12374 originalDecoder := decoder 12375 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12376 switch { 12377 default: 12378 // Do nothing and ignore the unexpected tag element 12379 err = decoder.Decoder.Skip() 12380 if err != nil { 12381 return err 12382 } 12383 12384 } 12385 decoder = originalDecoder 12386 } 12387 *v = sv 12388 return nil 12389} 12390 12391func awsRestxml_deserializeDocumentBuckets(v *[]types.Bucket, decoder smithyxml.NodeDecoder) error { 12392 if v == nil { 12393 return fmt.Errorf("unexpected nil of type %T", v) 12394 } 12395 var sv []types.Bucket 12396 if *v == nil { 12397 sv = make([]types.Bucket, 0) 12398 } else { 12399 sv = *v 12400 } 12401 12402 originalDecoder := decoder 12403 for { 12404 t, done, err := decoder.Token() 12405 if err != nil { 12406 return err 12407 } 12408 if done { 12409 break 12410 } 12411 switch { 12412 case strings.EqualFold("Bucket", t.Name.Local): 12413 var col types.Bucket 12414 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12415 destAddr := &col 12416 if err := awsRestxml_deserializeDocumentBucket(&destAddr, nodeDecoder); err != nil { 12417 return err 12418 } 12419 col = *destAddr 12420 sv = append(sv, col) 12421 12422 default: 12423 err = decoder.Decoder.Skip() 12424 if err != nil { 12425 return err 12426 } 12427 12428 } 12429 decoder = originalDecoder 12430 } 12431 *v = sv 12432 return nil 12433} 12434 12435func awsRestxml_deserializeDocumentBucketsUnwrapped(v *[]types.Bucket, decoder smithyxml.NodeDecoder) error { 12436 var sv []types.Bucket 12437 if *v == nil { 12438 sv = make([]types.Bucket, 0) 12439 } else { 12440 sv = *v 12441 } 12442 12443 switch { 12444 default: 12445 var mv types.Bucket 12446 t := decoder.StartEl 12447 _ = t 12448 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12449 destAddr := &mv 12450 if err := awsRestxml_deserializeDocumentBucket(&destAddr, nodeDecoder); err != nil { 12451 return err 12452 } 12453 mv = *destAddr 12454 sv = append(sv, mv) 12455 } 12456 *v = sv 12457 return nil 12458} 12459func awsRestxml_deserializeDocumentCommonPrefix(v **types.CommonPrefix, decoder smithyxml.NodeDecoder) error { 12460 if v == nil { 12461 return fmt.Errorf("unexpected nil of type %T", v) 12462 } 12463 var sv *types.CommonPrefix 12464 if *v == nil { 12465 sv = &types.CommonPrefix{} 12466 } else { 12467 sv = *v 12468 } 12469 12470 for { 12471 t, done, err := decoder.Token() 12472 if err != nil { 12473 return err 12474 } 12475 if done { 12476 break 12477 } 12478 originalDecoder := decoder 12479 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12480 switch { 12481 case strings.EqualFold("Prefix", t.Name.Local): 12482 val, err := decoder.Value() 12483 if err != nil { 12484 return err 12485 } 12486 if val == nil { 12487 break 12488 } 12489 { 12490 xtv := string(val) 12491 sv.Prefix = ptr.String(xtv) 12492 } 12493 12494 default: 12495 // Do nothing and ignore the unexpected tag element 12496 err = decoder.Decoder.Skip() 12497 if err != nil { 12498 return err 12499 } 12500 12501 } 12502 decoder = originalDecoder 12503 } 12504 *v = sv 12505 return nil 12506} 12507 12508func awsRestxml_deserializeDocumentCommonPrefixList(v *[]types.CommonPrefix, decoder smithyxml.NodeDecoder) error { 12509 if v == nil { 12510 return fmt.Errorf("unexpected nil of type %T", v) 12511 } 12512 var sv []types.CommonPrefix 12513 if *v == nil { 12514 sv = make([]types.CommonPrefix, 0) 12515 } else { 12516 sv = *v 12517 } 12518 12519 originalDecoder := decoder 12520 for { 12521 t, done, err := decoder.Token() 12522 if err != nil { 12523 return err 12524 } 12525 if done { 12526 break 12527 } 12528 switch { 12529 case strings.EqualFold("member", t.Name.Local): 12530 var col types.CommonPrefix 12531 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12532 destAddr := &col 12533 if err := awsRestxml_deserializeDocumentCommonPrefix(&destAddr, nodeDecoder); err != nil { 12534 return err 12535 } 12536 col = *destAddr 12537 sv = append(sv, col) 12538 12539 default: 12540 err = decoder.Decoder.Skip() 12541 if err != nil { 12542 return err 12543 } 12544 12545 } 12546 decoder = originalDecoder 12547 } 12548 *v = sv 12549 return nil 12550} 12551 12552func awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(v *[]types.CommonPrefix, decoder smithyxml.NodeDecoder) error { 12553 var sv []types.CommonPrefix 12554 if *v == nil { 12555 sv = make([]types.CommonPrefix, 0) 12556 } else { 12557 sv = *v 12558 } 12559 12560 switch { 12561 default: 12562 var mv types.CommonPrefix 12563 t := decoder.StartEl 12564 _ = t 12565 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12566 destAddr := &mv 12567 if err := awsRestxml_deserializeDocumentCommonPrefix(&destAddr, nodeDecoder); err != nil { 12568 return err 12569 } 12570 mv = *destAddr 12571 sv = append(sv, mv) 12572 } 12573 *v = sv 12574 return nil 12575} 12576func awsRestxml_deserializeDocumentCondition(v **types.Condition, decoder smithyxml.NodeDecoder) error { 12577 if v == nil { 12578 return fmt.Errorf("unexpected nil of type %T", v) 12579 } 12580 var sv *types.Condition 12581 if *v == nil { 12582 sv = &types.Condition{} 12583 } else { 12584 sv = *v 12585 } 12586 12587 for { 12588 t, done, err := decoder.Token() 12589 if err != nil { 12590 return err 12591 } 12592 if done { 12593 break 12594 } 12595 originalDecoder := decoder 12596 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12597 switch { 12598 case strings.EqualFold("HttpErrorCodeReturnedEquals", t.Name.Local): 12599 val, err := decoder.Value() 12600 if err != nil { 12601 return err 12602 } 12603 if val == nil { 12604 break 12605 } 12606 { 12607 xtv := string(val) 12608 sv.HttpErrorCodeReturnedEquals = ptr.String(xtv) 12609 } 12610 12611 case strings.EqualFold("KeyPrefixEquals", t.Name.Local): 12612 val, err := decoder.Value() 12613 if err != nil { 12614 return err 12615 } 12616 if val == nil { 12617 break 12618 } 12619 { 12620 xtv := string(val) 12621 sv.KeyPrefixEquals = ptr.String(xtv) 12622 } 12623 12624 default: 12625 // Do nothing and ignore the unexpected tag element 12626 err = decoder.Decoder.Skip() 12627 if err != nil { 12628 return err 12629 } 12630 12631 } 12632 decoder = originalDecoder 12633 } 12634 *v = sv 12635 return nil 12636} 12637 12638func awsRestxml_deserializeDocumentCopyObjectResult(v **types.CopyObjectResult, decoder smithyxml.NodeDecoder) error { 12639 if v == nil { 12640 return fmt.Errorf("unexpected nil of type %T", v) 12641 } 12642 var sv *types.CopyObjectResult 12643 if *v == nil { 12644 sv = &types.CopyObjectResult{} 12645 } else { 12646 sv = *v 12647 } 12648 12649 for { 12650 t, done, err := decoder.Token() 12651 if err != nil { 12652 return err 12653 } 12654 if done { 12655 break 12656 } 12657 originalDecoder := decoder 12658 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12659 switch { 12660 case strings.EqualFold("ETag", t.Name.Local): 12661 val, err := decoder.Value() 12662 if err != nil { 12663 return err 12664 } 12665 if val == nil { 12666 break 12667 } 12668 { 12669 xtv := string(val) 12670 sv.ETag = ptr.String(xtv) 12671 } 12672 12673 case strings.EqualFold("LastModified", t.Name.Local): 12674 val, err := decoder.Value() 12675 if err != nil { 12676 return err 12677 } 12678 if val == nil { 12679 break 12680 } 12681 { 12682 xtv := string(val) 12683 t, err := smithytime.ParseDateTime(xtv) 12684 if err != nil { 12685 return err 12686 } 12687 sv.LastModified = ptr.Time(t) 12688 } 12689 12690 default: 12691 // Do nothing and ignore the unexpected tag element 12692 err = decoder.Decoder.Skip() 12693 if err != nil { 12694 return err 12695 } 12696 12697 } 12698 decoder = originalDecoder 12699 } 12700 *v = sv 12701 return nil 12702} 12703 12704func awsRestxml_deserializeDocumentCopyPartResult(v **types.CopyPartResult, decoder smithyxml.NodeDecoder) error { 12705 if v == nil { 12706 return fmt.Errorf("unexpected nil of type %T", v) 12707 } 12708 var sv *types.CopyPartResult 12709 if *v == nil { 12710 sv = &types.CopyPartResult{} 12711 } else { 12712 sv = *v 12713 } 12714 12715 for { 12716 t, done, err := decoder.Token() 12717 if err != nil { 12718 return err 12719 } 12720 if done { 12721 break 12722 } 12723 originalDecoder := decoder 12724 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12725 switch { 12726 case strings.EqualFold("ETag", t.Name.Local): 12727 val, err := decoder.Value() 12728 if err != nil { 12729 return err 12730 } 12731 if val == nil { 12732 break 12733 } 12734 { 12735 xtv := string(val) 12736 sv.ETag = ptr.String(xtv) 12737 } 12738 12739 case strings.EqualFold("LastModified", t.Name.Local): 12740 val, err := decoder.Value() 12741 if err != nil { 12742 return err 12743 } 12744 if val == nil { 12745 break 12746 } 12747 { 12748 xtv := string(val) 12749 t, err := smithytime.ParseDateTime(xtv) 12750 if err != nil { 12751 return err 12752 } 12753 sv.LastModified = ptr.Time(t) 12754 } 12755 12756 default: 12757 // Do nothing and ignore the unexpected tag element 12758 err = decoder.Decoder.Skip() 12759 if err != nil { 12760 return err 12761 } 12762 12763 } 12764 decoder = originalDecoder 12765 } 12766 *v = sv 12767 return nil 12768} 12769 12770func awsRestxml_deserializeDocumentCORSRule(v **types.CORSRule, decoder smithyxml.NodeDecoder) error { 12771 if v == nil { 12772 return fmt.Errorf("unexpected nil of type %T", v) 12773 } 12774 var sv *types.CORSRule 12775 if *v == nil { 12776 sv = &types.CORSRule{} 12777 } else { 12778 sv = *v 12779 } 12780 12781 for { 12782 t, done, err := decoder.Token() 12783 if err != nil { 12784 return err 12785 } 12786 if done { 12787 break 12788 } 12789 originalDecoder := decoder 12790 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12791 switch { 12792 case strings.EqualFold("AllowedHeader", t.Name.Local): 12793 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12794 if err := awsRestxml_deserializeDocumentAllowedHeadersUnwrapped(&sv.AllowedHeaders, nodeDecoder); err != nil { 12795 return err 12796 } 12797 12798 case strings.EqualFold("AllowedMethod", t.Name.Local): 12799 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12800 if err := awsRestxml_deserializeDocumentAllowedMethodsUnwrapped(&sv.AllowedMethods, nodeDecoder); err != nil { 12801 return err 12802 } 12803 12804 case strings.EqualFold("AllowedOrigin", t.Name.Local): 12805 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12806 if err := awsRestxml_deserializeDocumentAllowedOriginsUnwrapped(&sv.AllowedOrigins, nodeDecoder); err != nil { 12807 return err 12808 } 12809 12810 case strings.EqualFold("ExposeHeader", t.Name.Local): 12811 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12812 if err := awsRestxml_deserializeDocumentExposeHeadersUnwrapped(&sv.ExposeHeaders, nodeDecoder); err != nil { 12813 return err 12814 } 12815 12816 case strings.EqualFold("MaxAgeSeconds", t.Name.Local): 12817 val, err := decoder.Value() 12818 if err != nil { 12819 return err 12820 } 12821 if val == nil { 12822 break 12823 } 12824 { 12825 xtv := string(val) 12826 i64, err := strconv.ParseInt(xtv, 10, 64) 12827 if err != nil { 12828 return err 12829 } 12830 sv.MaxAgeSeconds = int32(i64) 12831 } 12832 12833 default: 12834 // Do nothing and ignore the unexpected tag element 12835 err = decoder.Decoder.Skip() 12836 if err != nil { 12837 return err 12838 } 12839 12840 } 12841 decoder = originalDecoder 12842 } 12843 *v = sv 12844 return nil 12845} 12846 12847func awsRestxml_deserializeDocumentCORSRules(v *[]types.CORSRule, decoder smithyxml.NodeDecoder) error { 12848 if v == nil { 12849 return fmt.Errorf("unexpected nil of type %T", v) 12850 } 12851 var sv []types.CORSRule 12852 if *v == nil { 12853 sv = make([]types.CORSRule, 0) 12854 } else { 12855 sv = *v 12856 } 12857 12858 originalDecoder := decoder 12859 for { 12860 t, done, err := decoder.Token() 12861 if err != nil { 12862 return err 12863 } 12864 if done { 12865 break 12866 } 12867 switch { 12868 case strings.EqualFold("member", t.Name.Local): 12869 var col types.CORSRule 12870 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12871 destAddr := &col 12872 if err := awsRestxml_deserializeDocumentCORSRule(&destAddr, nodeDecoder); err != nil { 12873 return err 12874 } 12875 col = *destAddr 12876 sv = append(sv, col) 12877 12878 default: 12879 err = decoder.Decoder.Skip() 12880 if err != nil { 12881 return err 12882 } 12883 12884 } 12885 decoder = originalDecoder 12886 } 12887 *v = sv 12888 return nil 12889} 12890 12891func awsRestxml_deserializeDocumentCORSRulesUnwrapped(v *[]types.CORSRule, decoder smithyxml.NodeDecoder) error { 12892 var sv []types.CORSRule 12893 if *v == nil { 12894 sv = make([]types.CORSRule, 0) 12895 } else { 12896 sv = *v 12897 } 12898 12899 switch { 12900 default: 12901 var mv types.CORSRule 12902 t := decoder.StartEl 12903 _ = t 12904 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12905 destAddr := &mv 12906 if err := awsRestxml_deserializeDocumentCORSRule(&destAddr, nodeDecoder); err != nil { 12907 return err 12908 } 12909 mv = *destAddr 12910 sv = append(sv, mv) 12911 } 12912 *v = sv 12913 return nil 12914} 12915func awsRestxml_deserializeDocumentDefaultRetention(v **types.DefaultRetention, decoder smithyxml.NodeDecoder) error { 12916 if v == nil { 12917 return fmt.Errorf("unexpected nil of type %T", v) 12918 } 12919 var sv *types.DefaultRetention 12920 if *v == nil { 12921 sv = &types.DefaultRetention{} 12922 } else { 12923 sv = *v 12924 } 12925 12926 for { 12927 t, done, err := decoder.Token() 12928 if err != nil { 12929 return err 12930 } 12931 if done { 12932 break 12933 } 12934 originalDecoder := decoder 12935 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12936 switch { 12937 case strings.EqualFold("Days", t.Name.Local): 12938 val, err := decoder.Value() 12939 if err != nil { 12940 return err 12941 } 12942 if val == nil { 12943 break 12944 } 12945 { 12946 xtv := string(val) 12947 i64, err := strconv.ParseInt(xtv, 10, 64) 12948 if err != nil { 12949 return err 12950 } 12951 sv.Days = int32(i64) 12952 } 12953 12954 case strings.EqualFold("Mode", t.Name.Local): 12955 val, err := decoder.Value() 12956 if err != nil { 12957 return err 12958 } 12959 if val == nil { 12960 break 12961 } 12962 { 12963 xtv := string(val) 12964 sv.Mode = types.ObjectLockRetentionMode(xtv) 12965 } 12966 12967 case strings.EqualFold("Years", t.Name.Local): 12968 val, err := decoder.Value() 12969 if err != nil { 12970 return err 12971 } 12972 if val == nil { 12973 break 12974 } 12975 { 12976 xtv := string(val) 12977 i64, err := strconv.ParseInt(xtv, 10, 64) 12978 if err != nil { 12979 return err 12980 } 12981 sv.Years = int32(i64) 12982 } 12983 12984 default: 12985 // Do nothing and ignore the unexpected tag element 12986 err = decoder.Decoder.Skip() 12987 if err != nil { 12988 return err 12989 } 12990 12991 } 12992 decoder = originalDecoder 12993 } 12994 *v = sv 12995 return nil 12996} 12997 12998func awsRestxml_deserializeDocumentDeletedObject(v **types.DeletedObject, decoder smithyxml.NodeDecoder) error { 12999 if v == nil { 13000 return fmt.Errorf("unexpected nil of type %T", v) 13001 } 13002 var sv *types.DeletedObject 13003 if *v == nil { 13004 sv = &types.DeletedObject{} 13005 } else { 13006 sv = *v 13007 } 13008 13009 for { 13010 t, done, err := decoder.Token() 13011 if err != nil { 13012 return err 13013 } 13014 if done { 13015 break 13016 } 13017 originalDecoder := decoder 13018 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13019 switch { 13020 case strings.EqualFold("DeleteMarker", t.Name.Local): 13021 val, err := decoder.Value() 13022 if err != nil { 13023 return err 13024 } 13025 if val == nil { 13026 break 13027 } 13028 { 13029 xtv, err := strconv.ParseBool(string(val)) 13030 if err != nil { 13031 return fmt.Errorf("expected DeleteMarker to be of type *bool, got %T instead", val) 13032 } 13033 sv.DeleteMarker = xtv 13034 } 13035 13036 case strings.EqualFold("DeleteMarkerVersionId", t.Name.Local): 13037 val, err := decoder.Value() 13038 if err != nil { 13039 return err 13040 } 13041 if val == nil { 13042 break 13043 } 13044 { 13045 xtv := string(val) 13046 sv.DeleteMarkerVersionId = ptr.String(xtv) 13047 } 13048 13049 case strings.EqualFold("Key", t.Name.Local): 13050 val, err := decoder.Value() 13051 if err != nil { 13052 return err 13053 } 13054 if val == nil { 13055 break 13056 } 13057 { 13058 xtv := string(val) 13059 sv.Key = ptr.String(xtv) 13060 } 13061 13062 case strings.EqualFold("VersionId", t.Name.Local): 13063 val, err := decoder.Value() 13064 if err != nil { 13065 return err 13066 } 13067 if val == nil { 13068 break 13069 } 13070 { 13071 xtv := string(val) 13072 sv.VersionId = ptr.String(xtv) 13073 } 13074 13075 default: 13076 // Do nothing and ignore the unexpected tag element 13077 err = decoder.Decoder.Skip() 13078 if err != nil { 13079 return err 13080 } 13081 13082 } 13083 decoder = originalDecoder 13084 } 13085 *v = sv 13086 return nil 13087} 13088 13089func awsRestxml_deserializeDocumentDeletedObjects(v *[]types.DeletedObject, decoder smithyxml.NodeDecoder) error { 13090 if v == nil { 13091 return fmt.Errorf("unexpected nil of type %T", v) 13092 } 13093 var sv []types.DeletedObject 13094 if *v == nil { 13095 sv = make([]types.DeletedObject, 0) 13096 } else { 13097 sv = *v 13098 } 13099 13100 originalDecoder := decoder 13101 for { 13102 t, done, err := decoder.Token() 13103 if err != nil { 13104 return err 13105 } 13106 if done { 13107 break 13108 } 13109 switch { 13110 case strings.EqualFold("member", t.Name.Local): 13111 var col types.DeletedObject 13112 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13113 destAddr := &col 13114 if err := awsRestxml_deserializeDocumentDeletedObject(&destAddr, nodeDecoder); err != nil { 13115 return err 13116 } 13117 col = *destAddr 13118 sv = append(sv, col) 13119 13120 default: 13121 err = decoder.Decoder.Skip() 13122 if err != nil { 13123 return err 13124 } 13125 13126 } 13127 decoder = originalDecoder 13128 } 13129 *v = sv 13130 return nil 13131} 13132 13133func awsRestxml_deserializeDocumentDeletedObjectsUnwrapped(v *[]types.DeletedObject, decoder smithyxml.NodeDecoder) error { 13134 var sv []types.DeletedObject 13135 if *v == nil { 13136 sv = make([]types.DeletedObject, 0) 13137 } else { 13138 sv = *v 13139 } 13140 13141 switch { 13142 default: 13143 var mv types.DeletedObject 13144 t := decoder.StartEl 13145 _ = t 13146 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13147 destAddr := &mv 13148 if err := awsRestxml_deserializeDocumentDeletedObject(&destAddr, nodeDecoder); err != nil { 13149 return err 13150 } 13151 mv = *destAddr 13152 sv = append(sv, mv) 13153 } 13154 *v = sv 13155 return nil 13156} 13157func awsRestxml_deserializeDocumentDeleteMarkerEntry(v **types.DeleteMarkerEntry, decoder smithyxml.NodeDecoder) error { 13158 if v == nil { 13159 return fmt.Errorf("unexpected nil of type %T", v) 13160 } 13161 var sv *types.DeleteMarkerEntry 13162 if *v == nil { 13163 sv = &types.DeleteMarkerEntry{} 13164 } else { 13165 sv = *v 13166 } 13167 13168 for { 13169 t, done, err := decoder.Token() 13170 if err != nil { 13171 return err 13172 } 13173 if done { 13174 break 13175 } 13176 originalDecoder := decoder 13177 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13178 switch { 13179 case strings.EqualFold("IsLatest", t.Name.Local): 13180 val, err := decoder.Value() 13181 if err != nil { 13182 return err 13183 } 13184 if val == nil { 13185 break 13186 } 13187 { 13188 xtv, err := strconv.ParseBool(string(val)) 13189 if err != nil { 13190 return fmt.Errorf("expected IsLatest to be of type *bool, got %T instead", val) 13191 } 13192 sv.IsLatest = xtv 13193 } 13194 13195 case strings.EqualFold("Key", t.Name.Local): 13196 val, err := decoder.Value() 13197 if err != nil { 13198 return err 13199 } 13200 if val == nil { 13201 break 13202 } 13203 { 13204 xtv := string(val) 13205 sv.Key = ptr.String(xtv) 13206 } 13207 13208 case strings.EqualFold("LastModified", t.Name.Local): 13209 val, err := decoder.Value() 13210 if err != nil { 13211 return err 13212 } 13213 if val == nil { 13214 break 13215 } 13216 { 13217 xtv := string(val) 13218 t, err := smithytime.ParseDateTime(xtv) 13219 if err != nil { 13220 return err 13221 } 13222 sv.LastModified = ptr.Time(t) 13223 } 13224 13225 case strings.EqualFold("Owner", t.Name.Local): 13226 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13227 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 13228 return err 13229 } 13230 13231 case strings.EqualFold("VersionId", t.Name.Local): 13232 val, err := decoder.Value() 13233 if err != nil { 13234 return err 13235 } 13236 if val == nil { 13237 break 13238 } 13239 { 13240 xtv := string(val) 13241 sv.VersionId = ptr.String(xtv) 13242 } 13243 13244 default: 13245 // Do nothing and ignore the unexpected tag element 13246 err = decoder.Decoder.Skip() 13247 if err != nil { 13248 return err 13249 } 13250 13251 } 13252 decoder = originalDecoder 13253 } 13254 *v = sv 13255 return nil 13256} 13257 13258func awsRestxml_deserializeDocumentDeleteMarkerReplication(v **types.DeleteMarkerReplication, decoder smithyxml.NodeDecoder) error { 13259 if v == nil { 13260 return fmt.Errorf("unexpected nil of type %T", v) 13261 } 13262 var sv *types.DeleteMarkerReplication 13263 if *v == nil { 13264 sv = &types.DeleteMarkerReplication{} 13265 } else { 13266 sv = *v 13267 } 13268 13269 for { 13270 t, done, err := decoder.Token() 13271 if err != nil { 13272 return err 13273 } 13274 if done { 13275 break 13276 } 13277 originalDecoder := decoder 13278 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13279 switch { 13280 case strings.EqualFold("Status", t.Name.Local): 13281 val, err := decoder.Value() 13282 if err != nil { 13283 return err 13284 } 13285 if val == nil { 13286 break 13287 } 13288 { 13289 xtv := string(val) 13290 sv.Status = types.DeleteMarkerReplicationStatus(xtv) 13291 } 13292 13293 default: 13294 // Do nothing and ignore the unexpected tag element 13295 err = decoder.Decoder.Skip() 13296 if err != nil { 13297 return err 13298 } 13299 13300 } 13301 decoder = originalDecoder 13302 } 13303 *v = sv 13304 return nil 13305} 13306 13307func awsRestxml_deserializeDocumentDeleteMarkers(v *[]types.DeleteMarkerEntry, decoder smithyxml.NodeDecoder) error { 13308 if v == nil { 13309 return fmt.Errorf("unexpected nil of type %T", v) 13310 } 13311 var sv []types.DeleteMarkerEntry 13312 if *v == nil { 13313 sv = make([]types.DeleteMarkerEntry, 0) 13314 } else { 13315 sv = *v 13316 } 13317 13318 originalDecoder := decoder 13319 for { 13320 t, done, err := decoder.Token() 13321 if err != nil { 13322 return err 13323 } 13324 if done { 13325 break 13326 } 13327 switch { 13328 case strings.EqualFold("member", t.Name.Local): 13329 var col types.DeleteMarkerEntry 13330 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13331 destAddr := &col 13332 if err := awsRestxml_deserializeDocumentDeleteMarkerEntry(&destAddr, nodeDecoder); err != nil { 13333 return err 13334 } 13335 col = *destAddr 13336 sv = append(sv, col) 13337 13338 default: 13339 err = decoder.Decoder.Skip() 13340 if err != nil { 13341 return err 13342 } 13343 13344 } 13345 decoder = originalDecoder 13346 } 13347 *v = sv 13348 return nil 13349} 13350 13351func awsRestxml_deserializeDocumentDeleteMarkersUnwrapped(v *[]types.DeleteMarkerEntry, decoder smithyxml.NodeDecoder) error { 13352 var sv []types.DeleteMarkerEntry 13353 if *v == nil { 13354 sv = make([]types.DeleteMarkerEntry, 0) 13355 } else { 13356 sv = *v 13357 } 13358 13359 switch { 13360 default: 13361 var mv types.DeleteMarkerEntry 13362 t := decoder.StartEl 13363 _ = t 13364 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13365 destAddr := &mv 13366 if err := awsRestxml_deserializeDocumentDeleteMarkerEntry(&destAddr, nodeDecoder); err != nil { 13367 return err 13368 } 13369 mv = *destAddr 13370 sv = append(sv, mv) 13371 } 13372 *v = sv 13373 return nil 13374} 13375func awsRestxml_deserializeDocumentDestination(v **types.Destination, decoder smithyxml.NodeDecoder) error { 13376 if v == nil { 13377 return fmt.Errorf("unexpected nil of type %T", v) 13378 } 13379 var sv *types.Destination 13380 if *v == nil { 13381 sv = &types.Destination{} 13382 } else { 13383 sv = *v 13384 } 13385 13386 for { 13387 t, done, err := decoder.Token() 13388 if err != nil { 13389 return err 13390 } 13391 if done { 13392 break 13393 } 13394 originalDecoder := decoder 13395 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13396 switch { 13397 case strings.EqualFold("AccessControlTranslation", t.Name.Local): 13398 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13399 if err := awsRestxml_deserializeDocumentAccessControlTranslation(&sv.AccessControlTranslation, nodeDecoder); err != nil { 13400 return err 13401 } 13402 13403 case strings.EqualFold("Account", t.Name.Local): 13404 val, err := decoder.Value() 13405 if err != nil { 13406 return err 13407 } 13408 if val == nil { 13409 break 13410 } 13411 { 13412 xtv := string(val) 13413 sv.Account = ptr.String(xtv) 13414 } 13415 13416 case strings.EqualFold("Bucket", t.Name.Local): 13417 val, err := decoder.Value() 13418 if err != nil { 13419 return err 13420 } 13421 if val == nil { 13422 break 13423 } 13424 { 13425 xtv := string(val) 13426 sv.Bucket = ptr.String(xtv) 13427 } 13428 13429 case strings.EqualFold("EncryptionConfiguration", t.Name.Local): 13430 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13431 if err := awsRestxml_deserializeDocumentEncryptionConfiguration(&sv.EncryptionConfiguration, nodeDecoder); err != nil { 13432 return err 13433 } 13434 13435 case strings.EqualFold("Metrics", t.Name.Local): 13436 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13437 if err := awsRestxml_deserializeDocumentMetrics(&sv.Metrics, nodeDecoder); err != nil { 13438 return err 13439 } 13440 13441 case strings.EqualFold("ReplicationTime", t.Name.Local): 13442 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13443 if err := awsRestxml_deserializeDocumentReplicationTime(&sv.ReplicationTime, nodeDecoder); err != nil { 13444 return err 13445 } 13446 13447 case strings.EqualFold("StorageClass", t.Name.Local): 13448 val, err := decoder.Value() 13449 if err != nil { 13450 return err 13451 } 13452 if val == nil { 13453 break 13454 } 13455 { 13456 xtv := string(val) 13457 sv.StorageClass = types.StorageClass(xtv) 13458 } 13459 13460 default: 13461 // Do nothing and ignore the unexpected tag element 13462 err = decoder.Decoder.Skip() 13463 if err != nil { 13464 return err 13465 } 13466 13467 } 13468 decoder = originalDecoder 13469 } 13470 *v = sv 13471 return nil 13472} 13473 13474func awsRestxml_deserializeDocumentEncryptionConfiguration(v **types.EncryptionConfiguration, decoder smithyxml.NodeDecoder) error { 13475 if v == nil { 13476 return fmt.Errorf("unexpected nil of type %T", v) 13477 } 13478 var sv *types.EncryptionConfiguration 13479 if *v == nil { 13480 sv = &types.EncryptionConfiguration{} 13481 } else { 13482 sv = *v 13483 } 13484 13485 for { 13486 t, done, err := decoder.Token() 13487 if err != nil { 13488 return err 13489 } 13490 if done { 13491 break 13492 } 13493 originalDecoder := decoder 13494 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13495 switch { 13496 case strings.EqualFold("ReplicaKmsKeyID", t.Name.Local): 13497 val, err := decoder.Value() 13498 if err != nil { 13499 return err 13500 } 13501 if val == nil { 13502 break 13503 } 13504 { 13505 xtv := string(val) 13506 sv.ReplicaKmsKeyID = ptr.String(xtv) 13507 } 13508 13509 default: 13510 // Do nothing and ignore the unexpected tag element 13511 err = decoder.Decoder.Skip() 13512 if err != nil { 13513 return err 13514 } 13515 13516 } 13517 decoder = originalDecoder 13518 } 13519 *v = sv 13520 return nil 13521} 13522 13523func awsRestxml_deserializeDocumentError(v **types.Error, decoder smithyxml.NodeDecoder) error { 13524 if v == nil { 13525 return fmt.Errorf("unexpected nil of type %T", v) 13526 } 13527 var sv *types.Error 13528 if *v == nil { 13529 sv = &types.Error{} 13530 } else { 13531 sv = *v 13532 } 13533 13534 for { 13535 t, done, err := decoder.Token() 13536 if err != nil { 13537 return err 13538 } 13539 if done { 13540 break 13541 } 13542 originalDecoder := decoder 13543 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13544 switch { 13545 case strings.EqualFold("Code", t.Name.Local): 13546 val, err := decoder.Value() 13547 if err != nil { 13548 return err 13549 } 13550 if val == nil { 13551 break 13552 } 13553 { 13554 xtv := string(val) 13555 sv.Code = ptr.String(xtv) 13556 } 13557 13558 case strings.EqualFold("Key", t.Name.Local): 13559 val, err := decoder.Value() 13560 if err != nil { 13561 return err 13562 } 13563 if val == nil { 13564 break 13565 } 13566 { 13567 xtv := string(val) 13568 sv.Key = ptr.String(xtv) 13569 } 13570 13571 case strings.EqualFold("Message", t.Name.Local): 13572 val, err := decoder.Value() 13573 if err != nil { 13574 return err 13575 } 13576 if val == nil { 13577 break 13578 } 13579 { 13580 xtv := string(val) 13581 sv.Message = ptr.String(xtv) 13582 } 13583 13584 case strings.EqualFold("VersionId", t.Name.Local): 13585 val, err := decoder.Value() 13586 if err != nil { 13587 return err 13588 } 13589 if val == nil { 13590 break 13591 } 13592 { 13593 xtv := string(val) 13594 sv.VersionId = ptr.String(xtv) 13595 } 13596 13597 default: 13598 // Do nothing and ignore the unexpected tag element 13599 err = decoder.Decoder.Skip() 13600 if err != nil { 13601 return err 13602 } 13603 13604 } 13605 decoder = originalDecoder 13606 } 13607 *v = sv 13608 return nil 13609} 13610 13611func awsRestxml_deserializeDocumentErrorDocument(v **types.ErrorDocument, decoder smithyxml.NodeDecoder) error { 13612 if v == nil { 13613 return fmt.Errorf("unexpected nil of type %T", v) 13614 } 13615 var sv *types.ErrorDocument 13616 if *v == nil { 13617 sv = &types.ErrorDocument{} 13618 } else { 13619 sv = *v 13620 } 13621 13622 for { 13623 t, done, err := decoder.Token() 13624 if err != nil { 13625 return err 13626 } 13627 if done { 13628 break 13629 } 13630 originalDecoder := decoder 13631 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13632 switch { 13633 case strings.EqualFold("Key", t.Name.Local): 13634 val, err := decoder.Value() 13635 if err != nil { 13636 return err 13637 } 13638 if val == nil { 13639 break 13640 } 13641 { 13642 xtv := string(val) 13643 sv.Key = ptr.String(xtv) 13644 } 13645 13646 default: 13647 // Do nothing and ignore the unexpected tag element 13648 err = decoder.Decoder.Skip() 13649 if err != nil { 13650 return err 13651 } 13652 13653 } 13654 decoder = originalDecoder 13655 } 13656 *v = sv 13657 return nil 13658} 13659 13660func awsRestxml_deserializeDocumentErrors(v *[]types.Error, decoder smithyxml.NodeDecoder) error { 13661 if v == nil { 13662 return fmt.Errorf("unexpected nil of type %T", v) 13663 } 13664 var sv []types.Error 13665 if *v == nil { 13666 sv = make([]types.Error, 0) 13667 } else { 13668 sv = *v 13669 } 13670 13671 originalDecoder := decoder 13672 for { 13673 t, done, err := decoder.Token() 13674 if err != nil { 13675 return err 13676 } 13677 if done { 13678 break 13679 } 13680 switch { 13681 case strings.EqualFold("member", t.Name.Local): 13682 var col types.Error 13683 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13684 destAddr := &col 13685 if err := awsRestxml_deserializeDocumentError(&destAddr, nodeDecoder); err != nil { 13686 return err 13687 } 13688 col = *destAddr 13689 sv = append(sv, col) 13690 13691 default: 13692 err = decoder.Decoder.Skip() 13693 if err != nil { 13694 return err 13695 } 13696 13697 } 13698 decoder = originalDecoder 13699 } 13700 *v = sv 13701 return nil 13702} 13703 13704func awsRestxml_deserializeDocumentErrorsUnwrapped(v *[]types.Error, decoder smithyxml.NodeDecoder) error { 13705 var sv []types.Error 13706 if *v == nil { 13707 sv = make([]types.Error, 0) 13708 } else { 13709 sv = *v 13710 } 13711 13712 switch { 13713 default: 13714 var mv types.Error 13715 t := decoder.StartEl 13716 _ = t 13717 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13718 destAddr := &mv 13719 if err := awsRestxml_deserializeDocumentError(&destAddr, nodeDecoder); err != nil { 13720 return err 13721 } 13722 mv = *destAddr 13723 sv = append(sv, mv) 13724 } 13725 *v = sv 13726 return nil 13727} 13728func awsRestxml_deserializeDocumentEventList(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 13729 if v == nil { 13730 return fmt.Errorf("unexpected nil of type %T", v) 13731 } 13732 var sv []types.Event 13733 if *v == nil { 13734 sv = make([]types.Event, 0) 13735 } else { 13736 sv = *v 13737 } 13738 13739 originalDecoder := decoder 13740 for { 13741 t, done, err := decoder.Token() 13742 if err != nil { 13743 return err 13744 } 13745 if done { 13746 break 13747 } 13748 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13749 decoder = memberDecoder 13750 switch { 13751 case strings.EqualFold("member", t.Name.Local): 13752 var col types.Event 13753 val, err := decoder.Value() 13754 if err != nil { 13755 return err 13756 } 13757 if val == nil { 13758 break 13759 } 13760 { 13761 xtv := string(val) 13762 col = types.Event(xtv) 13763 } 13764 sv = append(sv, col) 13765 13766 default: 13767 err = decoder.Decoder.Skip() 13768 if err != nil { 13769 return err 13770 } 13771 13772 } 13773 decoder = originalDecoder 13774 } 13775 *v = sv 13776 return nil 13777} 13778 13779func awsRestxml_deserializeDocumentEventListUnwrapped(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 13780 var sv []types.Event 13781 if *v == nil { 13782 sv = make([]types.Event, 0) 13783 } else { 13784 sv = *v 13785 } 13786 13787 switch { 13788 default: 13789 var mv types.Event 13790 t := decoder.StartEl 13791 _ = t 13792 val, err := decoder.Value() 13793 if err != nil { 13794 return err 13795 } 13796 if val == nil { 13797 break 13798 } 13799 { 13800 xtv := string(val) 13801 mv = types.Event(xtv) 13802 } 13803 sv = append(sv, mv) 13804 } 13805 *v = sv 13806 return nil 13807} 13808func awsRestxml_deserializeDocumentExistingObjectReplication(v **types.ExistingObjectReplication, decoder smithyxml.NodeDecoder) error { 13809 if v == nil { 13810 return fmt.Errorf("unexpected nil of type %T", v) 13811 } 13812 var sv *types.ExistingObjectReplication 13813 if *v == nil { 13814 sv = &types.ExistingObjectReplication{} 13815 } else { 13816 sv = *v 13817 } 13818 13819 for { 13820 t, done, err := decoder.Token() 13821 if err != nil { 13822 return err 13823 } 13824 if done { 13825 break 13826 } 13827 originalDecoder := decoder 13828 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13829 switch { 13830 case strings.EqualFold("Status", t.Name.Local): 13831 val, err := decoder.Value() 13832 if err != nil { 13833 return err 13834 } 13835 if val == nil { 13836 break 13837 } 13838 { 13839 xtv := string(val) 13840 sv.Status = types.ExistingObjectReplicationStatus(xtv) 13841 } 13842 13843 default: 13844 // Do nothing and ignore the unexpected tag element 13845 err = decoder.Decoder.Skip() 13846 if err != nil { 13847 return err 13848 } 13849 13850 } 13851 decoder = originalDecoder 13852 } 13853 *v = sv 13854 return nil 13855} 13856 13857func awsRestxml_deserializeDocumentExposeHeaders(v *[]string, decoder smithyxml.NodeDecoder) error { 13858 if v == nil { 13859 return fmt.Errorf("unexpected nil of type %T", v) 13860 } 13861 var sv []string 13862 if *v == nil { 13863 sv = make([]string, 0) 13864 } else { 13865 sv = *v 13866 } 13867 13868 originalDecoder := decoder 13869 for { 13870 t, done, err := decoder.Token() 13871 if err != nil { 13872 return err 13873 } 13874 if done { 13875 break 13876 } 13877 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13878 decoder = memberDecoder 13879 switch { 13880 case strings.EqualFold("member", t.Name.Local): 13881 var col string 13882 val, err := decoder.Value() 13883 if err != nil { 13884 return err 13885 } 13886 if val == nil { 13887 break 13888 } 13889 { 13890 xtv := string(val) 13891 col = xtv 13892 } 13893 sv = append(sv, col) 13894 13895 default: 13896 err = decoder.Decoder.Skip() 13897 if err != nil { 13898 return err 13899 } 13900 13901 } 13902 decoder = originalDecoder 13903 } 13904 *v = sv 13905 return nil 13906} 13907 13908func awsRestxml_deserializeDocumentExposeHeadersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13909 var sv []string 13910 if *v == nil { 13911 sv = make([]string, 0) 13912 } else { 13913 sv = *v 13914 } 13915 13916 switch { 13917 default: 13918 var mv string 13919 t := decoder.StartEl 13920 _ = t 13921 val, err := decoder.Value() 13922 if err != nil { 13923 return err 13924 } 13925 if val == nil { 13926 break 13927 } 13928 { 13929 xtv := string(val) 13930 mv = xtv 13931 } 13932 sv = append(sv, mv) 13933 } 13934 *v = sv 13935 return nil 13936} 13937func awsRestxml_deserializeDocumentFilterRule(v **types.FilterRule, decoder smithyxml.NodeDecoder) error { 13938 if v == nil { 13939 return fmt.Errorf("unexpected nil of type %T", v) 13940 } 13941 var sv *types.FilterRule 13942 if *v == nil { 13943 sv = &types.FilterRule{} 13944 } else { 13945 sv = *v 13946 } 13947 13948 for { 13949 t, done, err := decoder.Token() 13950 if err != nil { 13951 return err 13952 } 13953 if done { 13954 break 13955 } 13956 originalDecoder := decoder 13957 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13958 switch { 13959 case strings.EqualFold("Name", t.Name.Local): 13960 val, err := decoder.Value() 13961 if err != nil { 13962 return err 13963 } 13964 if val == nil { 13965 break 13966 } 13967 { 13968 xtv := string(val) 13969 sv.Name = types.FilterRuleName(xtv) 13970 } 13971 13972 case strings.EqualFold("Value", t.Name.Local): 13973 val, err := decoder.Value() 13974 if err != nil { 13975 return err 13976 } 13977 if val == nil { 13978 break 13979 } 13980 { 13981 xtv := string(val) 13982 sv.Value = ptr.String(xtv) 13983 } 13984 13985 default: 13986 // Do nothing and ignore the unexpected tag element 13987 err = decoder.Decoder.Skip() 13988 if err != nil { 13989 return err 13990 } 13991 13992 } 13993 decoder = originalDecoder 13994 } 13995 *v = sv 13996 return nil 13997} 13998 13999func awsRestxml_deserializeDocumentFilterRuleList(v *[]types.FilterRule, decoder smithyxml.NodeDecoder) error { 14000 if v == nil { 14001 return fmt.Errorf("unexpected nil of type %T", v) 14002 } 14003 var sv []types.FilterRule 14004 if *v == nil { 14005 sv = make([]types.FilterRule, 0) 14006 } else { 14007 sv = *v 14008 } 14009 14010 originalDecoder := decoder 14011 for { 14012 t, done, err := decoder.Token() 14013 if err != nil { 14014 return err 14015 } 14016 if done { 14017 break 14018 } 14019 switch { 14020 case strings.EqualFold("member", t.Name.Local): 14021 var col types.FilterRule 14022 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14023 destAddr := &col 14024 if err := awsRestxml_deserializeDocumentFilterRule(&destAddr, nodeDecoder); err != nil { 14025 return err 14026 } 14027 col = *destAddr 14028 sv = append(sv, col) 14029 14030 default: 14031 err = decoder.Decoder.Skip() 14032 if err != nil { 14033 return err 14034 } 14035 14036 } 14037 decoder = originalDecoder 14038 } 14039 *v = sv 14040 return nil 14041} 14042 14043func awsRestxml_deserializeDocumentFilterRuleListUnwrapped(v *[]types.FilterRule, decoder smithyxml.NodeDecoder) error { 14044 var sv []types.FilterRule 14045 if *v == nil { 14046 sv = make([]types.FilterRule, 0) 14047 } else { 14048 sv = *v 14049 } 14050 14051 switch { 14052 default: 14053 var mv types.FilterRule 14054 t := decoder.StartEl 14055 _ = t 14056 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14057 destAddr := &mv 14058 if err := awsRestxml_deserializeDocumentFilterRule(&destAddr, nodeDecoder); err != nil { 14059 return err 14060 } 14061 mv = *destAddr 14062 sv = append(sv, mv) 14063 } 14064 *v = sv 14065 return nil 14066} 14067func awsRestxml_deserializeDocumentGrant(v **types.Grant, decoder smithyxml.NodeDecoder) error { 14068 if v == nil { 14069 return fmt.Errorf("unexpected nil of type %T", v) 14070 } 14071 var sv *types.Grant 14072 if *v == nil { 14073 sv = &types.Grant{} 14074 } else { 14075 sv = *v 14076 } 14077 14078 for { 14079 t, done, err := decoder.Token() 14080 if err != nil { 14081 return err 14082 } 14083 if done { 14084 break 14085 } 14086 originalDecoder := decoder 14087 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14088 switch { 14089 case strings.EqualFold("Grantee", t.Name.Local): 14090 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14091 if err := awsRestxml_deserializeDocumentGrantee(&sv.Grantee, nodeDecoder); err != nil { 14092 return err 14093 } 14094 14095 case strings.EqualFold("Permission", t.Name.Local): 14096 val, err := decoder.Value() 14097 if err != nil { 14098 return err 14099 } 14100 if val == nil { 14101 break 14102 } 14103 { 14104 xtv := string(val) 14105 sv.Permission = types.Permission(xtv) 14106 } 14107 14108 default: 14109 // Do nothing and ignore the unexpected tag element 14110 err = decoder.Decoder.Skip() 14111 if err != nil { 14112 return err 14113 } 14114 14115 } 14116 decoder = originalDecoder 14117 } 14118 *v = sv 14119 return nil 14120} 14121 14122func awsRestxml_deserializeDocumentGrantee(v **types.Grantee, decoder smithyxml.NodeDecoder) error { 14123 if v == nil { 14124 return fmt.Errorf("unexpected nil of type %T", v) 14125 } 14126 var sv *types.Grantee 14127 if *v == nil { 14128 sv = &types.Grantee{} 14129 } else { 14130 sv = *v 14131 } 14132 14133 for _, attr := range decoder.StartEl.Attr { 14134 name := attr.Name.Local 14135 if len(attr.Name.Space) != 0 { 14136 name = attr.Name.Space + `:` + attr.Name.Local 14137 } 14138 switch { 14139 case strings.EqualFold("xsi:type", name): 14140 val := []byte(attr.Value) 14141 { 14142 xtv := string(val) 14143 sv.Type = types.Type(xtv) 14144 } 14145 14146 } 14147 } 14148 for { 14149 t, done, err := decoder.Token() 14150 if err != nil { 14151 return err 14152 } 14153 if done { 14154 break 14155 } 14156 originalDecoder := decoder 14157 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14158 switch { 14159 case strings.EqualFold("DisplayName", t.Name.Local): 14160 val, err := decoder.Value() 14161 if err != nil { 14162 return err 14163 } 14164 if val == nil { 14165 break 14166 } 14167 { 14168 xtv := string(val) 14169 sv.DisplayName = ptr.String(xtv) 14170 } 14171 14172 case strings.EqualFold("EmailAddress", t.Name.Local): 14173 val, err := decoder.Value() 14174 if err != nil { 14175 return err 14176 } 14177 if val == nil { 14178 break 14179 } 14180 { 14181 xtv := string(val) 14182 sv.EmailAddress = ptr.String(xtv) 14183 } 14184 14185 case strings.EqualFold("ID", t.Name.Local): 14186 val, err := decoder.Value() 14187 if err != nil { 14188 return err 14189 } 14190 if val == nil { 14191 break 14192 } 14193 { 14194 xtv := string(val) 14195 sv.ID = ptr.String(xtv) 14196 } 14197 14198 case strings.EqualFold("URI", t.Name.Local): 14199 val, err := decoder.Value() 14200 if err != nil { 14201 return err 14202 } 14203 if val == nil { 14204 break 14205 } 14206 { 14207 xtv := string(val) 14208 sv.URI = ptr.String(xtv) 14209 } 14210 14211 default: 14212 // Do nothing and ignore the unexpected tag element 14213 err = decoder.Decoder.Skip() 14214 if err != nil { 14215 return err 14216 } 14217 14218 } 14219 decoder = originalDecoder 14220 } 14221 *v = sv 14222 return nil 14223} 14224 14225func awsRestxml_deserializeDocumentGrants(v *[]types.Grant, decoder smithyxml.NodeDecoder) error { 14226 if v == nil { 14227 return fmt.Errorf("unexpected nil of type %T", v) 14228 } 14229 var sv []types.Grant 14230 if *v == nil { 14231 sv = make([]types.Grant, 0) 14232 } else { 14233 sv = *v 14234 } 14235 14236 originalDecoder := decoder 14237 for { 14238 t, done, err := decoder.Token() 14239 if err != nil { 14240 return err 14241 } 14242 if done { 14243 break 14244 } 14245 switch { 14246 case strings.EqualFold("Grant", t.Name.Local): 14247 var col types.Grant 14248 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14249 destAddr := &col 14250 if err := awsRestxml_deserializeDocumentGrant(&destAddr, nodeDecoder); err != nil { 14251 return err 14252 } 14253 col = *destAddr 14254 sv = append(sv, col) 14255 14256 default: 14257 err = decoder.Decoder.Skip() 14258 if err != nil { 14259 return err 14260 } 14261 14262 } 14263 decoder = originalDecoder 14264 } 14265 *v = sv 14266 return nil 14267} 14268 14269func awsRestxml_deserializeDocumentGrantsUnwrapped(v *[]types.Grant, decoder smithyxml.NodeDecoder) error { 14270 var sv []types.Grant 14271 if *v == nil { 14272 sv = make([]types.Grant, 0) 14273 } else { 14274 sv = *v 14275 } 14276 14277 switch { 14278 default: 14279 var mv types.Grant 14280 t := decoder.StartEl 14281 _ = t 14282 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14283 destAddr := &mv 14284 if err := awsRestxml_deserializeDocumentGrant(&destAddr, nodeDecoder); err != nil { 14285 return err 14286 } 14287 mv = *destAddr 14288 sv = append(sv, mv) 14289 } 14290 *v = sv 14291 return nil 14292} 14293func awsRestxml_deserializeDocumentIndexDocument(v **types.IndexDocument, decoder smithyxml.NodeDecoder) error { 14294 if v == nil { 14295 return fmt.Errorf("unexpected nil of type %T", v) 14296 } 14297 var sv *types.IndexDocument 14298 if *v == nil { 14299 sv = &types.IndexDocument{} 14300 } else { 14301 sv = *v 14302 } 14303 14304 for { 14305 t, done, err := decoder.Token() 14306 if err != nil { 14307 return err 14308 } 14309 if done { 14310 break 14311 } 14312 originalDecoder := decoder 14313 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14314 switch { 14315 case strings.EqualFold("Suffix", t.Name.Local): 14316 val, err := decoder.Value() 14317 if err != nil { 14318 return err 14319 } 14320 if val == nil { 14321 break 14322 } 14323 { 14324 xtv := string(val) 14325 sv.Suffix = ptr.String(xtv) 14326 } 14327 14328 default: 14329 // Do nothing and ignore the unexpected tag element 14330 err = decoder.Decoder.Skip() 14331 if err != nil { 14332 return err 14333 } 14334 14335 } 14336 decoder = originalDecoder 14337 } 14338 *v = sv 14339 return nil 14340} 14341 14342func awsRestxml_deserializeDocumentInitiator(v **types.Initiator, decoder smithyxml.NodeDecoder) error { 14343 if v == nil { 14344 return fmt.Errorf("unexpected nil of type %T", v) 14345 } 14346 var sv *types.Initiator 14347 if *v == nil { 14348 sv = &types.Initiator{} 14349 } else { 14350 sv = *v 14351 } 14352 14353 for { 14354 t, done, err := decoder.Token() 14355 if err != nil { 14356 return err 14357 } 14358 if done { 14359 break 14360 } 14361 originalDecoder := decoder 14362 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14363 switch { 14364 case strings.EqualFold("DisplayName", t.Name.Local): 14365 val, err := decoder.Value() 14366 if err != nil { 14367 return err 14368 } 14369 if val == nil { 14370 break 14371 } 14372 { 14373 xtv := string(val) 14374 sv.DisplayName = ptr.String(xtv) 14375 } 14376 14377 case strings.EqualFold("ID", t.Name.Local): 14378 val, err := decoder.Value() 14379 if err != nil { 14380 return err 14381 } 14382 if val == nil { 14383 break 14384 } 14385 { 14386 xtv := string(val) 14387 sv.ID = ptr.String(xtv) 14388 } 14389 14390 default: 14391 // Do nothing and ignore the unexpected tag element 14392 err = decoder.Decoder.Skip() 14393 if err != nil { 14394 return err 14395 } 14396 14397 } 14398 decoder = originalDecoder 14399 } 14400 *v = sv 14401 return nil 14402} 14403 14404func awsRestxml_deserializeDocumentIntelligentTieringAndOperator(v **types.IntelligentTieringAndOperator, decoder smithyxml.NodeDecoder) error { 14405 if v == nil { 14406 return fmt.Errorf("unexpected nil of type %T", v) 14407 } 14408 var sv *types.IntelligentTieringAndOperator 14409 if *v == nil { 14410 sv = &types.IntelligentTieringAndOperator{} 14411 } else { 14412 sv = *v 14413 } 14414 14415 for { 14416 t, done, err := decoder.Token() 14417 if err != nil { 14418 return err 14419 } 14420 if done { 14421 break 14422 } 14423 originalDecoder := decoder 14424 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14425 switch { 14426 case strings.EqualFold("Prefix", t.Name.Local): 14427 val, err := decoder.Value() 14428 if err != nil { 14429 return err 14430 } 14431 if val == nil { 14432 break 14433 } 14434 { 14435 xtv := string(val) 14436 sv.Prefix = ptr.String(xtv) 14437 } 14438 14439 case strings.EqualFold("Tag", t.Name.Local): 14440 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14441 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 14442 return err 14443 } 14444 14445 default: 14446 // Do nothing and ignore the unexpected tag element 14447 err = decoder.Decoder.Skip() 14448 if err != nil { 14449 return err 14450 } 14451 14452 } 14453 decoder = originalDecoder 14454 } 14455 *v = sv 14456 return nil 14457} 14458 14459func awsRestxml_deserializeDocumentIntelligentTieringConfiguration(v **types.IntelligentTieringConfiguration, decoder smithyxml.NodeDecoder) error { 14460 if v == nil { 14461 return fmt.Errorf("unexpected nil of type %T", v) 14462 } 14463 var sv *types.IntelligentTieringConfiguration 14464 if *v == nil { 14465 sv = &types.IntelligentTieringConfiguration{} 14466 } else { 14467 sv = *v 14468 } 14469 14470 for { 14471 t, done, err := decoder.Token() 14472 if err != nil { 14473 return err 14474 } 14475 if done { 14476 break 14477 } 14478 originalDecoder := decoder 14479 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14480 switch { 14481 case strings.EqualFold("Filter", t.Name.Local): 14482 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14483 if err := awsRestxml_deserializeDocumentIntelligentTieringFilter(&sv.Filter, nodeDecoder); err != nil { 14484 return err 14485 } 14486 14487 case strings.EqualFold("Id", t.Name.Local): 14488 val, err := decoder.Value() 14489 if err != nil { 14490 return err 14491 } 14492 if val == nil { 14493 break 14494 } 14495 { 14496 xtv := string(val) 14497 sv.Id = ptr.String(xtv) 14498 } 14499 14500 case strings.EqualFold("Status", t.Name.Local): 14501 val, err := decoder.Value() 14502 if err != nil { 14503 return err 14504 } 14505 if val == nil { 14506 break 14507 } 14508 { 14509 xtv := string(val) 14510 sv.Status = types.IntelligentTieringStatus(xtv) 14511 } 14512 14513 case strings.EqualFold("Tiering", t.Name.Local): 14514 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14515 if err := awsRestxml_deserializeDocumentTieringListUnwrapped(&sv.Tierings, nodeDecoder); err != nil { 14516 return err 14517 } 14518 14519 default: 14520 // Do nothing and ignore the unexpected tag element 14521 err = decoder.Decoder.Skip() 14522 if err != nil { 14523 return err 14524 } 14525 14526 } 14527 decoder = originalDecoder 14528 } 14529 *v = sv 14530 return nil 14531} 14532 14533func awsRestxml_deserializeDocumentIntelligentTieringConfigurationList(v *[]types.IntelligentTieringConfiguration, decoder smithyxml.NodeDecoder) error { 14534 if v == nil { 14535 return fmt.Errorf("unexpected nil of type %T", v) 14536 } 14537 var sv []types.IntelligentTieringConfiguration 14538 if *v == nil { 14539 sv = make([]types.IntelligentTieringConfiguration, 0) 14540 } else { 14541 sv = *v 14542 } 14543 14544 originalDecoder := decoder 14545 for { 14546 t, done, err := decoder.Token() 14547 if err != nil { 14548 return err 14549 } 14550 if done { 14551 break 14552 } 14553 switch { 14554 case strings.EqualFold("member", t.Name.Local): 14555 var col types.IntelligentTieringConfiguration 14556 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14557 destAddr := &col 14558 if err := awsRestxml_deserializeDocumentIntelligentTieringConfiguration(&destAddr, nodeDecoder); err != nil { 14559 return err 14560 } 14561 col = *destAddr 14562 sv = append(sv, col) 14563 14564 default: 14565 err = decoder.Decoder.Skip() 14566 if err != nil { 14567 return err 14568 } 14569 14570 } 14571 decoder = originalDecoder 14572 } 14573 *v = sv 14574 return nil 14575} 14576 14577func awsRestxml_deserializeDocumentIntelligentTieringConfigurationListUnwrapped(v *[]types.IntelligentTieringConfiguration, decoder smithyxml.NodeDecoder) error { 14578 var sv []types.IntelligentTieringConfiguration 14579 if *v == nil { 14580 sv = make([]types.IntelligentTieringConfiguration, 0) 14581 } else { 14582 sv = *v 14583 } 14584 14585 switch { 14586 default: 14587 var mv types.IntelligentTieringConfiguration 14588 t := decoder.StartEl 14589 _ = t 14590 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14591 destAddr := &mv 14592 if err := awsRestxml_deserializeDocumentIntelligentTieringConfiguration(&destAddr, nodeDecoder); err != nil { 14593 return err 14594 } 14595 mv = *destAddr 14596 sv = append(sv, mv) 14597 } 14598 *v = sv 14599 return nil 14600} 14601func awsRestxml_deserializeDocumentIntelligentTieringFilter(v **types.IntelligentTieringFilter, decoder smithyxml.NodeDecoder) error { 14602 if v == nil { 14603 return fmt.Errorf("unexpected nil of type %T", v) 14604 } 14605 var sv *types.IntelligentTieringFilter 14606 if *v == nil { 14607 sv = &types.IntelligentTieringFilter{} 14608 } else { 14609 sv = *v 14610 } 14611 14612 for { 14613 t, done, err := decoder.Token() 14614 if err != nil { 14615 return err 14616 } 14617 if done { 14618 break 14619 } 14620 originalDecoder := decoder 14621 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14622 switch { 14623 case strings.EqualFold("And", t.Name.Local): 14624 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14625 if err := awsRestxml_deserializeDocumentIntelligentTieringAndOperator(&sv.And, nodeDecoder); err != nil { 14626 return err 14627 } 14628 14629 case strings.EqualFold("Prefix", t.Name.Local): 14630 val, err := decoder.Value() 14631 if err != nil { 14632 return err 14633 } 14634 if val == nil { 14635 break 14636 } 14637 { 14638 xtv := string(val) 14639 sv.Prefix = ptr.String(xtv) 14640 } 14641 14642 case strings.EqualFold("Tag", t.Name.Local): 14643 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14644 if err := awsRestxml_deserializeDocumentTag(&sv.Tag, nodeDecoder); err != nil { 14645 return err 14646 } 14647 14648 default: 14649 // Do nothing and ignore the unexpected tag element 14650 err = decoder.Decoder.Skip() 14651 if err != nil { 14652 return err 14653 } 14654 14655 } 14656 decoder = originalDecoder 14657 } 14658 *v = sv 14659 return nil 14660} 14661 14662func awsRestxml_deserializeDocumentInvalidObjectState(v **types.InvalidObjectState, decoder smithyxml.NodeDecoder) error { 14663 if v == nil { 14664 return fmt.Errorf("unexpected nil of type %T", v) 14665 } 14666 var sv *types.InvalidObjectState 14667 if *v == nil { 14668 sv = &types.InvalidObjectState{} 14669 } else { 14670 sv = *v 14671 } 14672 14673 for { 14674 t, done, err := decoder.Token() 14675 if err != nil { 14676 return err 14677 } 14678 if done { 14679 break 14680 } 14681 originalDecoder := decoder 14682 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14683 switch { 14684 case strings.EqualFold("AccessTier", t.Name.Local): 14685 val, err := decoder.Value() 14686 if err != nil { 14687 return err 14688 } 14689 if val == nil { 14690 break 14691 } 14692 { 14693 xtv := string(val) 14694 sv.AccessTier = types.IntelligentTieringAccessTier(xtv) 14695 } 14696 14697 case strings.EqualFold("StorageClass", t.Name.Local): 14698 val, err := decoder.Value() 14699 if err != nil { 14700 return err 14701 } 14702 if val == nil { 14703 break 14704 } 14705 { 14706 xtv := string(val) 14707 sv.StorageClass = types.StorageClass(xtv) 14708 } 14709 14710 default: 14711 // Do nothing and ignore the unexpected tag element 14712 err = decoder.Decoder.Skip() 14713 if err != nil { 14714 return err 14715 } 14716 14717 } 14718 decoder = originalDecoder 14719 } 14720 *v = sv 14721 return nil 14722} 14723 14724func awsRestxml_deserializeDocumentInventoryConfiguration(v **types.InventoryConfiguration, decoder smithyxml.NodeDecoder) error { 14725 if v == nil { 14726 return fmt.Errorf("unexpected nil of type %T", v) 14727 } 14728 var sv *types.InventoryConfiguration 14729 if *v == nil { 14730 sv = &types.InventoryConfiguration{} 14731 } else { 14732 sv = *v 14733 } 14734 14735 for { 14736 t, done, err := decoder.Token() 14737 if err != nil { 14738 return err 14739 } 14740 if done { 14741 break 14742 } 14743 originalDecoder := decoder 14744 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14745 switch { 14746 case strings.EqualFold("Destination", t.Name.Local): 14747 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14748 if err := awsRestxml_deserializeDocumentInventoryDestination(&sv.Destination, nodeDecoder); err != nil { 14749 return err 14750 } 14751 14752 case strings.EqualFold("Filter", t.Name.Local): 14753 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14754 if err := awsRestxml_deserializeDocumentInventoryFilter(&sv.Filter, nodeDecoder); err != nil { 14755 return err 14756 } 14757 14758 case strings.EqualFold("Id", t.Name.Local): 14759 val, err := decoder.Value() 14760 if err != nil { 14761 return err 14762 } 14763 if val == nil { 14764 break 14765 } 14766 { 14767 xtv := string(val) 14768 sv.Id = ptr.String(xtv) 14769 } 14770 14771 case strings.EqualFold("IncludedObjectVersions", t.Name.Local): 14772 val, err := decoder.Value() 14773 if err != nil { 14774 return err 14775 } 14776 if val == nil { 14777 break 14778 } 14779 { 14780 xtv := string(val) 14781 sv.IncludedObjectVersions = types.InventoryIncludedObjectVersions(xtv) 14782 } 14783 14784 case strings.EqualFold("IsEnabled", t.Name.Local): 14785 val, err := decoder.Value() 14786 if err != nil { 14787 return err 14788 } 14789 if val == nil { 14790 break 14791 } 14792 { 14793 xtv, err := strconv.ParseBool(string(val)) 14794 if err != nil { 14795 return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val) 14796 } 14797 sv.IsEnabled = xtv 14798 } 14799 14800 case strings.EqualFold("OptionalFields", t.Name.Local): 14801 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14802 if err := awsRestxml_deserializeDocumentInventoryOptionalFields(&sv.OptionalFields, nodeDecoder); err != nil { 14803 return err 14804 } 14805 14806 case strings.EqualFold("Schedule", t.Name.Local): 14807 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14808 if err := awsRestxml_deserializeDocumentInventorySchedule(&sv.Schedule, nodeDecoder); err != nil { 14809 return err 14810 } 14811 14812 default: 14813 // Do nothing and ignore the unexpected tag element 14814 err = decoder.Decoder.Skip() 14815 if err != nil { 14816 return err 14817 } 14818 14819 } 14820 decoder = originalDecoder 14821 } 14822 *v = sv 14823 return nil 14824} 14825 14826func awsRestxml_deserializeDocumentInventoryConfigurationList(v *[]types.InventoryConfiguration, decoder smithyxml.NodeDecoder) error { 14827 if v == nil { 14828 return fmt.Errorf("unexpected nil of type %T", v) 14829 } 14830 var sv []types.InventoryConfiguration 14831 if *v == nil { 14832 sv = make([]types.InventoryConfiguration, 0) 14833 } else { 14834 sv = *v 14835 } 14836 14837 originalDecoder := decoder 14838 for { 14839 t, done, err := decoder.Token() 14840 if err != nil { 14841 return err 14842 } 14843 if done { 14844 break 14845 } 14846 switch { 14847 case strings.EqualFold("member", t.Name.Local): 14848 var col types.InventoryConfiguration 14849 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14850 destAddr := &col 14851 if err := awsRestxml_deserializeDocumentInventoryConfiguration(&destAddr, nodeDecoder); err != nil { 14852 return err 14853 } 14854 col = *destAddr 14855 sv = append(sv, col) 14856 14857 default: 14858 err = decoder.Decoder.Skip() 14859 if err != nil { 14860 return err 14861 } 14862 14863 } 14864 decoder = originalDecoder 14865 } 14866 *v = sv 14867 return nil 14868} 14869 14870func awsRestxml_deserializeDocumentInventoryConfigurationListUnwrapped(v *[]types.InventoryConfiguration, decoder smithyxml.NodeDecoder) error { 14871 var sv []types.InventoryConfiguration 14872 if *v == nil { 14873 sv = make([]types.InventoryConfiguration, 0) 14874 } else { 14875 sv = *v 14876 } 14877 14878 switch { 14879 default: 14880 var mv types.InventoryConfiguration 14881 t := decoder.StartEl 14882 _ = t 14883 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14884 destAddr := &mv 14885 if err := awsRestxml_deserializeDocumentInventoryConfiguration(&destAddr, nodeDecoder); err != nil { 14886 return err 14887 } 14888 mv = *destAddr 14889 sv = append(sv, mv) 14890 } 14891 *v = sv 14892 return nil 14893} 14894func awsRestxml_deserializeDocumentInventoryDestination(v **types.InventoryDestination, decoder smithyxml.NodeDecoder) error { 14895 if v == nil { 14896 return fmt.Errorf("unexpected nil of type %T", v) 14897 } 14898 var sv *types.InventoryDestination 14899 if *v == nil { 14900 sv = &types.InventoryDestination{} 14901 } else { 14902 sv = *v 14903 } 14904 14905 for { 14906 t, done, err := decoder.Token() 14907 if err != nil { 14908 return err 14909 } 14910 if done { 14911 break 14912 } 14913 originalDecoder := decoder 14914 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14915 switch { 14916 case strings.EqualFold("S3BucketDestination", t.Name.Local): 14917 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14918 if err := awsRestxml_deserializeDocumentInventoryS3BucketDestination(&sv.S3BucketDestination, nodeDecoder); err != nil { 14919 return err 14920 } 14921 14922 default: 14923 // Do nothing and ignore the unexpected tag element 14924 err = decoder.Decoder.Skip() 14925 if err != nil { 14926 return err 14927 } 14928 14929 } 14930 decoder = originalDecoder 14931 } 14932 *v = sv 14933 return nil 14934} 14935 14936func awsRestxml_deserializeDocumentInventoryEncryption(v **types.InventoryEncryption, decoder smithyxml.NodeDecoder) error { 14937 if v == nil { 14938 return fmt.Errorf("unexpected nil of type %T", v) 14939 } 14940 var sv *types.InventoryEncryption 14941 if *v == nil { 14942 sv = &types.InventoryEncryption{} 14943 } else { 14944 sv = *v 14945 } 14946 14947 for { 14948 t, done, err := decoder.Token() 14949 if err != nil { 14950 return err 14951 } 14952 if done { 14953 break 14954 } 14955 originalDecoder := decoder 14956 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14957 switch { 14958 case strings.EqualFold("SSE-KMS", t.Name.Local): 14959 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14960 if err := awsRestxml_deserializeDocumentSSEKMS(&sv.SSEKMS, nodeDecoder); err != nil { 14961 return err 14962 } 14963 14964 case strings.EqualFold("SSE-S3", t.Name.Local): 14965 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14966 if err := awsRestxml_deserializeDocumentSSES3(&sv.SSES3, nodeDecoder); err != nil { 14967 return err 14968 } 14969 14970 default: 14971 // Do nothing and ignore the unexpected tag element 14972 err = decoder.Decoder.Skip() 14973 if err != nil { 14974 return err 14975 } 14976 14977 } 14978 decoder = originalDecoder 14979 } 14980 *v = sv 14981 return nil 14982} 14983 14984func awsRestxml_deserializeDocumentInventoryFilter(v **types.InventoryFilter, decoder smithyxml.NodeDecoder) error { 14985 if v == nil { 14986 return fmt.Errorf("unexpected nil of type %T", v) 14987 } 14988 var sv *types.InventoryFilter 14989 if *v == nil { 14990 sv = &types.InventoryFilter{} 14991 } else { 14992 sv = *v 14993 } 14994 14995 for { 14996 t, done, err := decoder.Token() 14997 if err != nil { 14998 return err 14999 } 15000 if done { 15001 break 15002 } 15003 originalDecoder := decoder 15004 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15005 switch { 15006 case strings.EqualFold("Prefix", t.Name.Local): 15007 val, err := decoder.Value() 15008 if err != nil { 15009 return err 15010 } 15011 if val == nil { 15012 break 15013 } 15014 { 15015 xtv := string(val) 15016 sv.Prefix = ptr.String(xtv) 15017 } 15018 15019 default: 15020 // Do nothing and ignore the unexpected tag element 15021 err = decoder.Decoder.Skip() 15022 if err != nil { 15023 return err 15024 } 15025 15026 } 15027 decoder = originalDecoder 15028 } 15029 *v = sv 15030 return nil 15031} 15032 15033func awsRestxml_deserializeDocumentInventoryOptionalFields(v *[]types.InventoryOptionalField, decoder smithyxml.NodeDecoder) error { 15034 if v == nil { 15035 return fmt.Errorf("unexpected nil of type %T", v) 15036 } 15037 var sv []types.InventoryOptionalField 15038 if *v == nil { 15039 sv = make([]types.InventoryOptionalField, 0) 15040 } else { 15041 sv = *v 15042 } 15043 15044 originalDecoder := decoder 15045 for { 15046 t, done, err := decoder.Token() 15047 if err != nil { 15048 return err 15049 } 15050 if done { 15051 break 15052 } 15053 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15054 decoder = memberDecoder 15055 switch { 15056 case strings.EqualFold("Field", t.Name.Local): 15057 var col types.InventoryOptionalField 15058 val, err := decoder.Value() 15059 if err != nil { 15060 return err 15061 } 15062 if val == nil { 15063 break 15064 } 15065 { 15066 xtv := string(val) 15067 col = types.InventoryOptionalField(xtv) 15068 } 15069 sv = append(sv, col) 15070 15071 default: 15072 err = decoder.Decoder.Skip() 15073 if err != nil { 15074 return err 15075 } 15076 15077 } 15078 decoder = originalDecoder 15079 } 15080 *v = sv 15081 return nil 15082} 15083 15084func awsRestxml_deserializeDocumentInventoryOptionalFieldsUnwrapped(v *[]types.InventoryOptionalField, decoder smithyxml.NodeDecoder) error { 15085 var sv []types.InventoryOptionalField 15086 if *v == nil { 15087 sv = make([]types.InventoryOptionalField, 0) 15088 } else { 15089 sv = *v 15090 } 15091 15092 switch { 15093 default: 15094 var mv types.InventoryOptionalField 15095 t := decoder.StartEl 15096 _ = t 15097 val, err := decoder.Value() 15098 if err != nil { 15099 return err 15100 } 15101 if val == nil { 15102 break 15103 } 15104 { 15105 xtv := string(val) 15106 mv = types.InventoryOptionalField(xtv) 15107 } 15108 sv = append(sv, mv) 15109 } 15110 *v = sv 15111 return nil 15112} 15113func awsRestxml_deserializeDocumentInventoryS3BucketDestination(v **types.InventoryS3BucketDestination, decoder smithyxml.NodeDecoder) error { 15114 if v == nil { 15115 return fmt.Errorf("unexpected nil of type %T", v) 15116 } 15117 var sv *types.InventoryS3BucketDestination 15118 if *v == nil { 15119 sv = &types.InventoryS3BucketDestination{} 15120 } else { 15121 sv = *v 15122 } 15123 15124 for { 15125 t, done, err := decoder.Token() 15126 if err != nil { 15127 return err 15128 } 15129 if done { 15130 break 15131 } 15132 originalDecoder := decoder 15133 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15134 switch { 15135 case strings.EqualFold("AccountId", t.Name.Local): 15136 val, err := decoder.Value() 15137 if err != nil { 15138 return err 15139 } 15140 if val == nil { 15141 break 15142 } 15143 { 15144 xtv := string(val) 15145 sv.AccountId = ptr.String(xtv) 15146 } 15147 15148 case strings.EqualFold("Bucket", t.Name.Local): 15149 val, err := decoder.Value() 15150 if err != nil { 15151 return err 15152 } 15153 if val == nil { 15154 break 15155 } 15156 { 15157 xtv := string(val) 15158 sv.Bucket = ptr.String(xtv) 15159 } 15160 15161 case strings.EqualFold("Encryption", t.Name.Local): 15162 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15163 if err := awsRestxml_deserializeDocumentInventoryEncryption(&sv.Encryption, nodeDecoder); err != nil { 15164 return err 15165 } 15166 15167 case strings.EqualFold("Format", t.Name.Local): 15168 val, err := decoder.Value() 15169 if err != nil { 15170 return err 15171 } 15172 if val == nil { 15173 break 15174 } 15175 { 15176 xtv := string(val) 15177 sv.Format = types.InventoryFormat(xtv) 15178 } 15179 15180 case strings.EqualFold("Prefix", t.Name.Local): 15181 val, err := decoder.Value() 15182 if err != nil { 15183 return err 15184 } 15185 if val == nil { 15186 break 15187 } 15188 { 15189 xtv := string(val) 15190 sv.Prefix = ptr.String(xtv) 15191 } 15192 15193 default: 15194 // Do nothing and ignore the unexpected tag element 15195 err = decoder.Decoder.Skip() 15196 if err != nil { 15197 return err 15198 } 15199 15200 } 15201 decoder = originalDecoder 15202 } 15203 *v = sv 15204 return nil 15205} 15206 15207func awsRestxml_deserializeDocumentInventorySchedule(v **types.InventorySchedule, decoder smithyxml.NodeDecoder) error { 15208 if v == nil { 15209 return fmt.Errorf("unexpected nil of type %T", v) 15210 } 15211 var sv *types.InventorySchedule 15212 if *v == nil { 15213 sv = &types.InventorySchedule{} 15214 } else { 15215 sv = *v 15216 } 15217 15218 for { 15219 t, done, err := decoder.Token() 15220 if err != nil { 15221 return err 15222 } 15223 if done { 15224 break 15225 } 15226 originalDecoder := decoder 15227 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15228 switch { 15229 case strings.EqualFold("Frequency", t.Name.Local): 15230 val, err := decoder.Value() 15231 if err != nil { 15232 return err 15233 } 15234 if val == nil { 15235 break 15236 } 15237 { 15238 xtv := string(val) 15239 sv.Frequency = types.InventoryFrequency(xtv) 15240 } 15241 15242 default: 15243 // Do nothing and ignore the unexpected tag element 15244 err = decoder.Decoder.Skip() 15245 if err != nil { 15246 return err 15247 } 15248 15249 } 15250 decoder = originalDecoder 15251 } 15252 *v = sv 15253 return nil 15254} 15255 15256func awsRestxml_deserializeDocumentLambdaFunctionConfiguration(v **types.LambdaFunctionConfiguration, decoder smithyxml.NodeDecoder) error { 15257 if v == nil { 15258 return fmt.Errorf("unexpected nil of type %T", v) 15259 } 15260 var sv *types.LambdaFunctionConfiguration 15261 if *v == nil { 15262 sv = &types.LambdaFunctionConfiguration{} 15263 } else { 15264 sv = *v 15265 } 15266 15267 for { 15268 t, done, err := decoder.Token() 15269 if err != nil { 15270 return err 15271 } 15272 if done { 15273 break 15274 } 15275 originalDecoder := decoder 15276 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15277 switch { 15278 case strings.EqualFold("Event", t.Name.Local): 15279 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15280 if err := awsRestxml_deserializeDocumentEventListUnwrapped(&sv.Events, nodeDecoder); err != nil { 15281 return err 15282 } 15283 15284 case strings.EqualFold("Filter", t.Name.Local): 15285 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15286 if err := awsRestxml_deserializeDocumentNotificationConfigurationFilter(&sv.Filter, nodeDecoder); err != nil { 15287 return err 15288 } 15289 15290 case strings.EqualFold("Id", t.Name.Local): 15291 val, err := decoder.Value() 15292 if err != nil { 15293 return err 15294 } 15295 if val == nil { 15296 break 15297 } 15298 { 15299 xtv := string(val) 15300 sv.Id = ptr.String(xtv) 15301 } 15302 15303 case strings.EqualFold("CloudFunction", t.Name.Local): 15304 val, err := decoder.Value() 15305 if err != nil { 15306 return err 15307 } 15308 if val == nil { 15309 break 15310 } 15311 { 15312 xtv := string(val) 15313 sv.LambdaFunctionArn = ptr.String(xtv) 15314 } 15315 15316 default: 15317 // Do nothing and ignore the unexpected tag element 15318 err = decoder.Decoder.Skip() 15319 if err != nil { 15320 return err 15321 } 15322 15323 } 15324 decoder = originalDecoder 15325 } 15326 *v = sv 15327 return nil 15328} 15329 15330func awsRestxml_deserializeDocumentLambdaFunctionConfigurationList(v *[]types.LambdaFunctionConfiguration, decoder smithyxml.NodeDecoder) error { 15331 if v == nil { 15332 return fmt.Errorf("unexpected nil of type %T", v) 15333 } 15334 var sv []types.LambdaFunctionConfiguration 15335 if *v == nil { 15336 sv = make([]types.LambdaFunctionConfiguration, 0) 15337 } else { 15338 sv = *v 15339 } 15340 15341 originalDecoder := decoder 15342 for { 15343 t, done, err := decoder.Token() 15344 if err != nil { 15345 return err 15346 } 15347 if done { 15348 break 15349 } 15350 switch { 15351 case strings.EqualFold("member", t.Name.Local): 15352 var col types.LambdaFunctionConfiguration 15353 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15354 destAddr := &col 15355 if err := awsRestxml_deserializeDocumentLambdaFunctionConfiguration(&destAddr, nodeDecoder); err != nil { 15356 return err 15357 } 15358 col = *destAddr 15359 sv = append(sv, col) 15360 15361 default: 15362 err = decoder.Decoder.Skip() 15363 if err != nil { 15364 return err 15365 } 15366 15367 } 15368 decoder = originalDecoder 15369 } 15370 *v = sv 15371 return nil 15372} 15373 15374func awsRestxml_deserializeDocumentLambdaFunctionConfigurationListUnwrapped(v *[]types.LambdaFunctionConfiguration, decoder smithyxml.NodeDecoder) error { 15375 var sv []types.LambdaFunctionConfiguration 15376 if *v == nil { 15377 sv = make([]types.LambdaFunctionConfiguration, 0) 15378 } else { 15379 sv = *v 15380 } 15381 15382 switch { 15383 default: 15384 var mv types.LambdaFunctionConfiguration 15385 t := decoder.StartEl 15386 _ = t 15387 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15388 destAddr := &mv 15389 if err := awsRestxml_deserializeDocumentLambdaFunctionConfiguration(&destAddr, nodeDecoder); err != nil { 15390 return err 15391 } 15392 mv = *destAddr 15393 sv = append(sv, mv) 15394 } 15395 *v = sv 15396 return nil 15397} 15398func awsRestxml_deserializeDocumentLifecycleExpiration(v **types.LifecycleExpiration, decoder smithyxml.NodeDecoder) error { 15399 if v == nil { 15400 return fmt.Errorf("unexpected nil of type %T", v) 15401 } 15402 var sv *types.LifecycleExpiration 15403 if *v == nil { 15404 sv = &types.LifecycleExpiration{} 15405 } else { 15406 sv = *v 15407 } 15408 15409 for { 15410 t, done, err := decoder.Token() 15411 if err != nil { 15412 return err 15413 } 15414 if done { 15415 break 15416 } 15417 originalDecoder := decoder 15418 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15419 switch { 15420 case strings.EqualFold("Date", t.Name.Local): 15421 val, err := decoder.Value() 15422 if err != nil { 15423 return err 15424 } 15425 if val == nil { 15426 break 15427 } 15428 { 15429 xtv := string(val) 15430 t, err := smithytime.ParseDateTime(xtv) 15431 if err != nil { 15432 return err 15433 } 15434 sv.Date = ptr.Time(t) 15435 } 15436 15437 case strings.EqualFold("Days", t.Name.Local): 15438 val, err := decoder.Value() 15439 if err != nil { 15440 return err 15441 } 15442 if val == nil { 15443 break 15444 } 15445 { 15446 xtv := string(val) 15447 i64, err := strconv.ParseInt(xtv, 10, 64) 15448 if err != nil { 15449 return err 15450 } 15451 sv.Days = int32(i64) 15452 } 15453 15454 case strings.EqualFold("ExpiredObjectDeleteMarker", t.Name.Local): 15455 val, err := decoder.Value() 15456 if err != nil { 15457 return err 15458 } 15459 if val == nil { 15460 break 15461 } 15462 { 15463 xtv, err := strconv.ParseBool(string(val)) 15464 if err != nil { 15465 return fmt.Errorf("expected ExpiredObjectDeleteMarker to be of type *bool, got %T instead", val) 15466 } 15467 sv.ExpiredObjectDeleteMarker = xtv 15468 } 15469 15470 default: 15471 // Do nothing and ignore the unexpected tag element 15472 err = decoder.Decoder.Skip() 15473 if err != nil { 15474 return err 15475 } 15476 15477 } 15478 decoder = originalDecoder 15479 } 15480 *v = sv 15481 return nil 15482} 15483 15484func awsRestxml_deserializeDocumentLifecycleRule(v **types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 15485 if v == nil { 15486 return fmt.Errorf("unexpected nil of type %T", v) 15487 } 15488 var sv *types.LifecycleRule 15489 if *v == nil { 15490 sv = &types.LifecycleRule{} 15491 } else { 15492 sv = *v 15493 } 15494 15495 for { 15496 t, done, err := decoder.Token() 15497 if err != nil { 15498 return err 15499 } 15500 if done { 15501 break 15502 } 15503 originalDecoder := decoder 15504 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15505 switch { 15506 case strings.EqualFold("AbortIncompleteMultipartUpload", t.Name.Local): 15507 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15508 if err := awsRestxml_deserializeDocumentAbortIncompleteMultipartUpload(&sv.AbortIncompleteMultipartUpload, nodeDecoder); err != nil { 15509 return err 15510 } 15511 15512 case strings.EqualFold("Expiration", t.Name.Local): 15513 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15514 if err := awsRestxml_deserializeDocumentLifecycleExpiration(&sv.Expiration, nodeDecoder); err != nil { 15515 return err 15516 } 15517 15518 case strings.EqualFold("Filter", t.Name.Local): 15519 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15520 if err := awsRestxml_deserializeDocumentLifecycleRuleFilter(&sv.Filter, nodeDecoder); err != nil { 15521 return err 15522 } 15523 15524 case strings.EqualFold("ID", t.Name.Local): 15525 val, err := decoder.Value() 15526 if err != nil { 15527 return err 15528 } 15529 if val == nil { 15530 break 15531 } 15532 { 15533 xtv := string(val) 15534 sv.ID = ptr.String(xtv) 15535 } 15536 15537 case strings.EqualFold("NoncurrentVersionExpiration", t.Name.Local): 15538 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15539 if err := awsRestxml_deserializeDocumentNoncurrentVersionExpiration(&sv.NoncurrentVersionExpiration, nodeDecoder); err != nil { 15540 return err 15541 } 15542 15543 case strings.EqualFold("NoncurrentVersionTransition", t.Name.Local): 15544 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15545 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransitionListUnwrapped(&sv.NoncurrentVersionTransitions, nodeDecoder); err != nil { 15546 return err 15547 } 15548 15549 case strings.EqualFold("Prefix", t.Name.Local): 15550 val, err := decoder.Value() 15551 if err != nil { 15552 return err 15553 } 15554 if val == nil { 15555 break 15556 } 15557 { 15558 xtv := string(val) 15559 sv.Prefix = ptr.String(xtv) 15560 } 15561 15562 case strings.EqualFold("Status", t.Name.Local): 15563 val, err := decoder.Value() 15564 if err != nil { 15565 return err 15566 } 15567 if val == nil { 15568 break 15569 } 15570 { 15571 xtv := string(val) 15572 sv.Status = types.ExpirationStatus(xtv) 15573 } 15574 15575 case strings.EqualFold("Transition", t.Name.Local): 15576 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15577 if err := awsRestxml_deserializeDocumentTransitionListUnwrapped(&sv.Transitions, nodeDecoder); err != nil { 15578 return err 15579 } 15580 15581 default: 15582 // Do nothing and ignore the unexpected tag element 15583 err = decoder.Decoder.Skip() 15584 if err != nil { 15585 return err 15586 } 15587 15588 } 15589 decoder = originalDecoder 15590 } 15591 *v = sv 15592 return nil 15593} 15594 15595func awsRestxml_deserializeDocumentLifecycleRuleAndOperator(v **types.LifecycleRuleAndOperator, decoder smithyxml.NodeDecoder) error { 15596 if v == nil { 15597 return fmt.Errorf("unexpected nil of type %T", v) 15598 } 15599 var sv *types.LifecycleRuleAndOperator 15600 if *v == nil { 15601 sv = &types.LifecycleRuleAndOperator{} 15602 } else { 15603 sv = *v 15604 } 15605 15606 for { 15607 t, done, err := decoder.Token() 15608 if err != nil { 15609 return err 15610 } 15611 if done { 15612 break 15613 } 15614 originalDecoder := decoder 15615 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15616 switch { 15617 case strings.EqualFold("Prefix", t.Name.Local): 15618 val, err := decoder.Value() 15619 if err != nil { 15620 return err 15621 } 15622 if val == nil { 15623 break 15624 } 15625 { 15626 xtv := string(val) 15627 sv.Prefix = ptr.String(xtv) 15628 } 15629 15630 case strings.EqualFold("Tag", t.Name.Local): 15631 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15632 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 15633 return err 15634 } 15635 15636 default: 15637 // Do nothing and ignore the unexpected tag element 15638 err = decoder.Decoder.Skip() 15639 if err != nil { 15640 return err 15641 } 15642 15643 } 15644 decoder = originalDecoder 15645 } 15646 *v = sv 15647 return nil 15648} 15649 15650func awsRestxml_deserializeDocumentLifecycleRuleFilter(v *types.LifecycleRuleFilter, decoder smithyxml.NodeDecoder) error { 15651 if v == nil { 15652 return fmt.Errorf("unexpected nil of type %T", v) 15653 } 15654 var uv types.LifecycleRuleFilter 15655 var memberFound bool 15656 for { 15657 t, done, err := decoder.Token() 15658 if err != nil { 15659 return err 15660 } 15661 if done { 15662 break 15663 } 15664 if memberFound { 15665 if err = decoder.Decoder.Skip(); err != nil { 15666 return err 15667 } 15668 } 15669 originalDecoder := decoder 15670 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15671 switch { 15672 case strings.EqualFold("And", t.Name.Local): 15673 var mv types.LifecycleRuleAndOperator 15674 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15675 destAddr := &mv 15676 if err := awsRestxml_deserializeDocumentLifecycleRuleAndOperator(&destAddr, nodeDecoder); err != nil { 15677 return err 15678 } 15679 mv = *destAddr 15680 uv = &types.LifecycleRuleFilterMemberAnd{Value: mv} 15681 memberFound = true 15682 15683 case strings.EqualFold("Prefix", t.Name.Local): 15684 var mv string 15685 val, err := decoder.Value() 15686 if err != nil { 15687 return err 15688 } 15689 if val == nil { 15690 break 15691 } 15692 { 15693 xtv := string(val) 15694 mv = xtv 15695 } 15696 uv = &types.LifecycleRuleFilterMemberPrefix{Value: mv} 15697 memberFound = true 15698 15699 case strings.EqualFold("Tag", t.Name.Local): 15700 var mv types.Tag 15701 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15702 destAddr := &mv 15703 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 15704 return err 15705 } 15706 mv = *destAddr 15707 uv = &types.LifecycleRuleFilterMemberTag{Value: mv} 15708 memberFound = true 15709 15710 default: 15711 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 15712 memberFound = true 15713 15714 } 15715 decoder = originalDecoder 15716 } 15717 *v = uv 15718 return nil 15719} 15720 15721func awsRestxml_deserializeDocumentLifecycleRules(v *[]types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 15722 if v == nil { 15723 return fmt.Errorf("unexpected nil of type %T", v) 15724 } 15725 var sv []types.LifecycleRule 15726 if *v == nil { 15727 sv = make([]types.LifecycleRule, 0) 15728 } else { 15729 sv = *v 15730 } 15731 15732 originalDecoder := decoder 15733 for { 15734 t, done, err := decoder.Token() 15735 if err != nil { 15736 return err 15737 } 15738 if done { 15739 break 15740 } 15741 switch { 15742 case strings.EqualFold("member", t.Name.Local): 15743 var col types.LifecycleRule 15744 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15745 destAddr := &col 15746 if err := awsRestxml_deserializeDocumentLifecycleRule(&destAddr, nodeDecoder); err != nil { 15747 return err 15748 } 15749 col = *destAddr 15750 sv = append(sv, col) 15751 15752 default: 15753 err = decoder.Decoder.Skip() 15754 if err != nil { 15755 return err 15756 } 15757 15758 } 15759 decoder = originalDecoder 15760 } 15761 *v = sv 15762 return nil 15763} 15764 15765func awsRestxml_deserializeDocumentLifecycleRulesUnwrapped(v *[]types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 15766 var sv []types.LifecycleRule 15767 if *v == nil { 15768 sv = make([]types.LifecycleRule, 0) 15769 } else { 15770 sv = *v 15771 } 15772 15773 switch { 15774 default: 15775 var mv types.LifecycleRule 15776 t := decoder.StartEl 15777 _ = t 15778 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15779 destAddr := &mv 15780 if err := awsRestxml_deserializeDocumentLifecycleRule(&destAddr, nodeDecoder); err != nil { 15781 return err 15782 } 15783 mv = *destAddr 15784 sv = append(sv, mv) 15785 } 15786 *v = sv 15787 return nil 15788} 15789func awsRestxml_deserializeDocumentLoggingEnabled(v **types.LoggingEnabled, decoder smithyxml.NodeDecoder) error { 15790 if v == nil { 15791 return fmt.Errorf("unexpected nil of type %T", v) 15792 } 15793 var sv *types.LoggingEnabled 15794 if *v == nil { 15795 sv = &types.LoggingEnabled{} 15796 } else { 15797 sv = *v 15798 } 15799 15800 for { 15801 t, done, err := decoder.Token() 15802 if err != nil { 15803 return err 15804 } 15805 if done { 15806 break 15807 } 15808 originalDecoder := decoder 15809 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15810 switch { 15811 case strings.EqualFold("TargetBucket", t.Name.Local): 15812 val, err := decoder.Value() 15813 if err != nil { 15814 return err 15815 } 15816 if val == nil { 15817 break 15818 } 15819 { 15820 xtv := string(val) 15821 sv.TargetBucket = ptr.String(xtv) 15822 } 15823 15824 case strings.EqualFold("TargetGrants", t.Name.Local): 15825 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15826 if err := awsRestxml_deserializeDocumentTargetGrants(&sv.TargetGrants, nodeDecoder); err != nil { 15827 return err 15828 } 15829 15830 case strings.EqualFold("TargetPrefix", t.Name.Local): 15831 val, err := decoder.Value() 15832 if err != nil { 15833 return err 15834 } 15835 if val == nil { 15836 break 15837 } 15838 { 15839 xtv := string(val) 15840 sv.TargetPrefix = ptr.String(xtv) 15841 } 15842 15843 default: 15844 // Do nothing and ignore the unexpected tag element 15845 err = decoder.Decoder.Skip() 15846 if err != nil { 15847 return err 15848 } 15849 15850 } 15851 decoder = originalDecoder 15852 } 15853 *v = sv 15854 return nil 15855} 15856 15857func awsRestxml_deserializeDocumentMetrics(v **types.Metrics, decoder smithyxml.NodeDecoder) error { 15858 if v == nil { 15859 return fmt.Errorf("unexpected nil of type %T", v) 15860 } 15861 var sv *types.Metrics 15862 if *v == nil { 15863 sv = &types.Metrics{} 15864 } else { 15865 sv = *v 15866 } 15867 15868 for { 15869 t, done, err := decoder.Token() 15870 if err != nil { 15871 return err 15872 } 15873 if done { 15874 break 15875 } 15876 originalDecoder := decoder 15877 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15878 switch { 15879 case strings.EqualFold("EventThreshold", t.Name.Local): 15880 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15881 if err := awsRestxml_deserializeDocumentReplicationTimeValue(&sv.EventThreshold, nodeDecoder); err != nil { 15882 return err 15883 } 15884 15885 case strings.EqualFold("Status", t.Name.Local): 15886 val, err := decoder.Value() 15887 if err != nil { 15888 return err 15889 } 15890 if val == nil { 15891 break 15892 } 15893 { 15894 xtv := string(val) 15895 sv.Status = types.MetricsStatus(xtv) 15896 } 15897 15898 default: 15899 // Do nothing and ignore the unexpected tag element 15900 err = decoder.Decoder.Skip() 15901 if err != nil { 15902 return err 15903 } 15904 15905 } 15906 decoder = originalDecoder 15907 } 15908 *v = sv 15909 return nil 15910} 15911 15912func awsRestxml_deserializeDocumentMetricsAndOperator(v **types.MetricsAndOperator, decoder smithyxml.NodeDecoder) error { 15913 if v == nil { 15914 return fmt.Errorf("unexpected nil of type %T", v) 15915 } 15916 var sv *types.MetricsAndOperator 15917 if *v == nil { 15918 sv = &types.MetricsAndOperator{} 15919 } else { 15920 sv = *v 15921 } 15922 15923 for { 15924 t, done, err := decoder.Token() 15925 if err != nil { 15926 return err 15927 } 15928 if done { 15929 break 15930 } 15931 originalDecoder := decoder 15932 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15933 switch { 15934 case strings.EqualFold("Prefix", t.Name.Local): 15935 val, err := decoder.Value() 15936 if err != nil { 15937 return err 15938 } 15939 if val == nil { 15940 break 15941 } 15942 { 15943 xtv := string(val) 15944 sv.Prefix = ptr.String(xtv) 15945 } 15946 15947 case strings.EqualFold("Tag", t.Name.Local): 15948 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15949 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 15950 return err 15951 } 15952 15953 default: 15954 // Do nothing and ignore the unexpected tag element 15955 err = decoder.Decoder.Skip() 15956 if err != nil { 15957 return err 15958 } 15959 15960 } 15961 decoder = originalDecoder 15962 } 15963 *v = sv 15964 return nil 15965} 15966 15967func awsRestxml_deserializeDocumentMetricsConfiguration(v **types.MetricsConfiguration, decoder smithyxml.NodeDecoder) error { 15968 if v == nil { 15969 return fmt.Errorf("unexpected nil of type %T", v) 15970 } 15971 var sv *types.MetricsConfiguration 15972 if *v == nil { 15973 sv = &types.MetricsConfiguration{} 15974 } else { 15975 sv = *v 15976 } 15977 15978 for { 15979 t, done, err := decoder.Token() 15980 if err != nil { 15981 return err 15982 } 15983 if done { 15984 break 15985 } 15986 originalDecoder := decoder 15987 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15988 switch { 15989 case strings.EqualFold("Filter", t.Name.Local): 15990 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15991 if err := awsRestxml_deserializeDocumentMetricsFilter(&sv.Filter, nodeDecoder); err != nil { 15992 return err 15993 } 15994 15995 case strings.EqualFold("Id", t.Name.Local): 15996 val, err := decoder.Value() 15997 if err != nil { 15998 return err 15999 } 16000 if val == nil { 16001 break 16002 } 16003 { 16004 xtv := string(val) 16005 sv.Id = ptr.String(xtv) 16006 } 16007 16008 default: 16009 // Do nothing and ignore the unexpected tag element 16010 err = decoder.Decoder.Skip() 16011 if err != nil { 16012 return err 16013 } 16014 16015 } 16016 decoder = originalDecoder 16017 } 16018 *v = sv 16019 return nil 16020} 16021 16022func awsRestxml_deserializeDocumentMetricsConfigurationList(v *[]types.MetricsConfiguration, decoder smithyxml.NodeDecoder) error { 16023 if v == nil { 16024 return fmt.Errorf("unexpected nil of type %T", v) 16025 } 16026 var sv []types.MetricsConfiguration 16027 if *v == nil { 16028 sv = make([]types.MetricsConfiguration, 0) 16029 } else { 16030 sv = *v 16031 } 16032 16033 originalDecoder := decoder 16034 for { 16035 t, done, err := decoder.Token() 16036 if err != nil { 16037 return err 16038 } 16039 if done { 16040 break 16041 } 16042 switch { 16043 case strings.EqualFold("member", t.Name.Local): 16044 var col types.MetricsConfiguration 16045 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16046 destAddr := &col 16047 if err := awsRestxml_deserializeDocumentMetricsConfiguration(&destAddr, nodeDecoder); err != nil { 16048 return err 16049 } 16050 col = *destAddr 16051 sv = append(sv, col) 16052 16053 default: 16054 err = decoder.Decoder.Skip() 16055 if err != nil { 16056 return err 16057 } 16058 16059 } 16060 decoder = originalDecoder 16061 } 16062 *v = sv 16063 return nil 16064} 16065 16066func awsRestxml_deserializeDocumentMetricsConfigurationListUnwrapped(v *[]types.MetricsConfiguration, decoder smithyxml.NodeDecoder) error { 16067 var sv []types.MetricsConfiguration 16068 if *v == nil { 16069 sv = make([]types.MetricsConfiguration, 0) 16070 } else { 16071 sv = *v 16072 } 16073 16074 switch { 16075 default: 16076 var mv types.MetricsConfiguration 16077 t := decoder.StartEl 16078 _ = t 16079 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16080 destAddr := &mv 16081 if err := awsRestxml_deserializeDocumentMetricsConfiguration(&destAddr, nodeDecoder); err != nil { 16082 return err 16083 } 16084 mv = *destAddr 16085 sv = append(sv, mv) 16086 } 16087 *v = sv 16088 return nil 16089} 16090func awsRestxml_deserializeDocumentMetricsFilter(v *types.MetricsFilter, decoder smithyxml.NodeDecoder) error { 16091 if v == nil { 16092 return fmt.Errorf("unexpected nil of type %T", v) 16093 } 16094 var uv types.MetricsFilter 16095 var memberFound bool 16096 for { 16097 t, done, err := decoder.Token() 16098 if err != nil { 16099 return err 16100 } 16101 if done { 16102 break 16103 } 16104 if memberFound { 16105 if err = decoder.Decoder.Skip(); err != nil { 16106 return err 16107 } 16108 } 16109 originalDecoder := decoder 16110 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16111 switch { 16112 case strings.EqualFold("And", t.Name.Local): 16113 var mv types.MetricsAndOperator 16114 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16115 destAddr := &mv 16116 if err := awsRestxml_deserializeDocumentMetricsAndOperator(&destAddr, nodeDecoder); err != nil { 16117 return err 16118 } 16119 mv = *destAddr 16120 uv = &types.MetricsFilterMemberAnd{Value: mv} 16121 memberFound = true 16122 16123 case strings.EqualFold("Prefix", t.Name.Local): 16124 var mv string 16125 val, err := decoder.Value() 16126 if err != nil { 16127 return err 16128 } 16129 if val == nil { 16130 break 16131 } 16132 { 16133 xtv := string(val) 16134 mv = xtv 16135 } 16136 uv = &types.MetricsFilterMemberPrefix{Value: mv} 16137 memberFound = true 16138 16139 case strings.EqualFold("Tag", t.Name.Local): 16140 var mv types.Tag 16141 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16142 destAddr := &mv 16143 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 16144 return err 16145 } 16146 mv = *destAddr 16147 uv = &types.MetricsFilterMemberTag{Value: mv} 16148 memberFound = true 16149 16150 default: 16151 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 16152 memberFound = true 16153 16154 } 16155 decoder = originalDecoder 16156 } 16157 *v = uv 16158 return nil 16159} 16160 16161func awsRestxml_deserializeDocumentMultipartUpload(v **types.MultipartUpload, decoder smithyxml.NodeDecoder) error { 16162 if v == nil { 16163 return fmt.Errorf("unexpected nil of type %T", v) 16164 } 16165 var sv *types.MultipartUpload 16166 if *v == nil { 16167 sv = &types.MultipartUpload{} 16168 } else { 16169 sv = *v 16170 } 16171 16172 for { 16173 t, done, err := decoder.Token() 16174 if err != nil { 16175 return err 16176 } 16177 if done { 16178 break 16179 } 16180 originalDecoder := decoder 16181 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16182 switch { 16183 case strings.EqualFold("Initiated", t.Name.Local): 16184 val, err := decoder.Value() 16185 if err != nil { 16186 return err 16187 } 16188 if val == nil { 16189 break 16190 } 16191 { 16192 xtv := string(val) 16193 t, err := smithytime.ParseDateTime(xtv) 16194 if err != nil { 16195 return err 16196 } 16197 sv.Initiated = ptr.Time(t) 16198 } 16199 16200 case strings.EqualFold("Initiator", t.Name.Local): 16201 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16202 if err := awsRestxml_deserializeDocumentInitiator(&sv.Initiator, nodeDecoder); err != nil { 16203 return err 16204 } 16205 16206 case strings.EqualFold("Key", t.Name.Local): 16207 val, err := decoder.Value() 16208 if err != nil { 16209 return err 16210 } 16211 if val == nil { 16212 break 16213 } 16214 { 16215 xtv := string(val) 16216 sv.Key = ptr.String(xtv) 16217 } 16218 16219 case strings.EqualFold("Owner", t.Name.Local): 16220 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16221 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 16222 return err 16223 } 16224 16225 case strings.EqualFold("StorageClass", t.Name.Local): 16226 val, err := decoder.Value() 16227 if err != nil { 16228 return err 16229 } 16230 if val == nil { 16231 break 16232 } 16233 { 16234 xtv := string(val) 16235 sv.StorageClass = types.StorageClass(xtv) 16236 } 16237 16238 case strings.EqualFold("UploadId", t.Name.Local): 16239 val, err := decoder.Value() 16240 if err != nil { 16241 return err 16242 } 16243 if val == nil { 16244 break 16245 } 16246 { 16247 xtv := string(val) 16248 sv.UploadId = ptr.String(xtv) 16249 } 16250 16251 default: 16252 // Do nothing and ignore the unexpected tag element 16253 err = decoder.Decoder.Skip() 16254 if err != nil { 16255 return err 16256 } 16257 16258 } 16259 decoder = originalDecoder 16260 } 16261 *v = sv 16262 return nil 16263} 16264 16265func awsRestxml_deserializeDocumentMultipartUploadList(v *[]types.MultipartUpload, decoder smithyxml.NodeDecoder) error { 16266 if v == nil { 16267 return fmt.Errorf("unexpected nil of type %T", v) 16268 } 16269 var sv []types.MultipartUpload 16270 if *v == nil { 16271 sv = make([]types.MultipartUpload, 0) 16272 } else { 16273 sv = *v 16274 } 16275 16276 originalDecoder := decoder 16277 for { 16278 t, done, err := decoder.Token() 16279 if err != nil { 16280 return err 16281 } 16282 if done { 16283 break 16284 } 16285 switch { 16286 case strings.EqualFold("member", t.Name.Local): 16287 var col types.MultipartUpload 16288 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16289 destAddr := &col 16290 if err := awsRestxml_deserializeDocumentMultipartUpload(&destAddr, nodeDecoder); err != nil { 16291 return err 16292 } 16293 col = *destAddr 16294 sv = append(sv, col) 16295 16296 default: 16297 err = decoder.Decoder.Skip() 16298 if err != nil { 16299 return err 16300 } 16301 16302 } 16303 decoder = originalDecoder 16304 } 16305 *v = sv 16306 return nil 16307} 16308 16309func awsRestxml_deserializeDocumentMultipartUploadListUnwrapped(v *[]types.MultipartUpload, decoder smithyxml.NodeDecoder) error { 16310 var sv []types.MultipartUpload 16311 if *v == nil { 16312 sv = make([]types.MultipartUpload, 0) 16313 } else { 16314 sv = *v 16315 } 16316 16317 switch { 16318 default: 16319 var mv types.MultipartUpload 16320 t := decoder.StartEl 16321 _ = t 16322 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16323 destAddr := &mv 16324 if err := awsRestxml_deserializeDocumentMultipartUpload(&destAddr, nodeDecoder); err != nil { 16325 return err 16326 } 16327 mv = *destAddr 16328 sv = append(sv, mv) 16329 } 16330 *v = sv 16331 return nil 16332} 16333func awsRestxml_deserializeDocumentNoncurrentVersionExpiration(v **types.NoncurrentVersionExpiration, decoder smithyxml.NodeDecoder) error { 16334 if v == nil { 16335 return fmt.Errorf("unexpected nil of type %T", v) 16336 } 16337 var sv *types.NoncurrentVersionExpiration 16338 if *v == nil { 16339 sv = &types.NoncurrentVersionExpiration{} 16340 } else { 16341 sv = *v 16342 } 16343 16344 for { 16345 t, done, err := decoder.Token() 16346 if err != nil { 16347 return err 16348 } 16349 if done { 16350 break 16351 } 16352 originalDecoder := decoder 16353 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16354 switch { 16355 case strings.EqualFold("NoncurrentDays", t.Name.Local): 16356 val, err := decoder.Value() 16357 if err != nil { 16358 return err 16359 } 16360 if val == nil { 16361 break 16362 } 16363 { 16364 xtv := string(val) 16365 i64, err := strconv.ParseInt(xtv, 10, 64) 16366 if err != nil { 16367 return err 16368 } 16369 sv.NoncurrentDays = int32(i64) 16370 } 16371 16372 default: 16373 // Do nothing and ignore the unexpected tag element 16374 err = decoder.Decoder.Skip() 16375 if err != nil { 16376 return err 16377 } 16378 16379 } 16380 decoder = originalDecoder 16381 } 16382 *v = sv 16383 return nil 16384} 16385 16386func awsRestxml_deserializeDocumentNoncurrentVersionTransition(v **types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 16387 if v == nil { 16388 return fmt.Errorf("unexpected nil of type %T", v) 16389 } 16390 var sv *types.NoncurrentVersionTransition 16391 if *v == nil { 16392 sv = &types.NoncurrentVersionTransition{} 16393 } else { 16394 sv = *v 16395 } 16396 16397 for { 16398 t, done, err := decoder.Token() 16399 if err != nil { 16400 return err 16401 } 16402 if done { 16403 break 16404 } 16405 originalDecoder := decoder 16406 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16407 switch { 16408 case strings.EqualFold("NoncurrentDays", t.Name.Local): 16409 val, err := decoder.Value() 16410 if err != nil { 16411 return err 16412 } 16413 if val == nil { 16414 break 16415 } 16416 { 16417 xtv := string(val) 16418 i64, err := strconv.ParseInt(xtv, 10, 64) 16419 if err != nil { 16420 return err 16421 } 16422 sv.NoncurrentDays = int32(i64) 16423 } 16424 16425 case strings.EqualFold("StorageClass", t.Name.Local): 16426 val, err := decoder.Value() 16427 if err != nil { 16428 return err 16429 } 16430 if val == nil { 16431 break 16432 } 16433 { 16434 xtv := string(val) 16435 sv.StorageClass = types.TransitionStorageClass(xtv) 16436 } 16437 16438 default: 16439 // Do nothing and ignore the unexpected tag element 16440 err = decoder.Decoder.Skip() 16441 if err != nil { 16442 return err 16443 } 16444 16445 } 16446 decoder = originalDecoder 16447 } 16448 *v = sv 16449 return nil 16450} 16451 16452func awsRestxml_deserializeDocumentNoncurrentVersionTransitionList(v *[]types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 16453 if v == nil { 16454 return fmt.Errorf("unexpected nil of type %T", v) 16455 } 16456 var sv []types.NoncurrentVersionTransition 16457 if *v == nil { 16458 sv = make([]types.NoncurrentVersionTransition, 0) 16459 } else { 16460 sv = *v 16461 } 16462 16463 originalDecoder := decoder 16464 for { 16465 t, done, err := decoder.Token() 16466 if err != nil { 16467 return err 16468 } 16469 if done { 16470 break 16471 } 16472 switch { 16473 case strings.EqualFold("member", t.Name.Local): 16474 var col types.NoncurrentVersionTransition 16475 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16476 destAddr := &col 16477 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransition(&destAddr, nodeDecoder); err != nil { 16478 return err 16479 } 16480 col = *destAddr 16481 sv = append(sv, col) 16482 16483 default: 16484 err = decoder.Decoder.Skip() 16485 if err != nil { 16486 return err 16487 } 16488 16489 } 16490 decoder = originalDecoder 16491 } 16492 *v = sv 16493 return nil 16494} 16495 16496func awsRestxml_deserializeDocumentNoncurrentVersionTransitionListUnwrapped(v *[]types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 16497 var sv []types.NoncurrentVersionTransition 16498 if *v == nil { 16499 sv = make([]types.NoncurrentVersionTransition, 0) 16500 } else { 16501 sv = *v 16502 } 16503 16504 switch { 16505 default: 16506 var mv types.NoncurrentVersionTransition 16507 t := decoder.StartEl 16508 _ = t 16509 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16510 destAddr := &mv 16511 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransition(&destAddr, nodeDecoder); err != nil { 16512 return err 16513 } 16514 mv = *destAddr 16515 sv = append(sv, mv) 16516 } 16517 *v = sv 16518 return nil 16519} 16520func awsRestxml_deserializeDocumentNoSuchBucket(v **types.NoSuchBucket, decoder smithyxml.NodeDecoder) error { 16521 if v == nil { 16522 return fmt.Errorf("unexpected nil of type %T", v) 16523 } 16524 var sv *types.NoSuchBucket 16525 if *v == nil { 16526 sv = &types.NoSuchBucket{} 16527 } else { 16528 sv = *v 16529 } 16530 16531 for { 16532 t, done, err := decoder.Token() 16533 if err != nil { 16534 return err 16535 } 16536 if done { 16537 break 16538 } 16539 originalDecoder := decoder 16540 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16541 switch { 16542 default: 16543 // Do nothing and ignore the unexpected tag element 16544 err = decoder.Decoder.Skip() 16545 if err != nil { 16546 return err 16547 } 16548 16549 } 16550 decoder = originalDecoder 16551 } 16552 *v = sv 16553 return nil 16554} 16555 16556func awsRestxml_deserializeDocumentNoSuchKey(v **types.NoSuchKey, decoder smithyxml.NodeDecoder) error { 16557 if v == nil { 16558 return fmt.Errorf("unexpected nil of type %T", v) 16559 } 16560 var sv *types.NoSuchKey 16561 if *v == nil { 16562 sv = &types.NoSuchKey{} 16563 } else { 16564 sv = *v 16565 } 16566 16567 for { 16568 t, done, err := decoder.Token() 16569 if err != nil { 16570 return err 16571 } 16572 if done { 16573 break 16574 } 16575 originalDecoder := decoder 16576 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16577 switch { 16578 default: 16579 // Do nothing and ignore the unexpected tag element 16580 err = decoder.Decoder.Skip() 16581 if err != nil { 16582 return err 16583 } 16584 16585 } 16586 decoder = originalDecoder 16587 } 16588 *v = sv 16589 return nil 16590} 16591 16592func awsRestxml_deserializeDocumentNoSuchUpload(v **types.NoSuchUpload, decoder smithyxml.NodeDecoder) error { 16593 if v == nil { 16594 return fmt.Errorf("unexpected nil of type %T", v) 16595 } 16596 var sv *types.NoSuchUpload 16597 if *v == nil { 16598 sv = &types.NoSuchUpload{} 16599 } else { 16600 sv = *v 16601 } 16602 16603 for { 16604 t, done, err := decoder.Token() 16605 if err != nil { 16606 return err 16607 } 16608 if done { 16609 break 16610 } 16611 originalDecoder := decoder 16612 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16613 switch { 16614 default: 16615 // Do nothing and ignore the unexpected tag element 16616 err = decoder.Decoder.Skip() 16617 if err != nil { 16618 return err 16619 } 16620 16621 } 16622 decoder = originalDecoder 16623 } 16624 *v = sv 16625 return nil 16626} 16627 16628func awsRestxml_deserializeDocumentNotFound(v **types.NotFound, decoder smithyxml.NodeDecoder) error { 16629 if v == nil { 16630 return fmt.Errorf("unexpected nil of type %T", v) 16631 } 16632 var sv *types.NotFound 16633 if *v == nil { 16634 sv = &types.NotFound{} 16635 } else { 16636 sv = *v 16637 } 16638 16639 for { 16640 t, done, err := decoder.Token() 16641 if err != nil { 16642 return err 16643 } 16644 if done { 16645 break 16646 } 16647 originalDecoder := decoder 16648 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16649 switch { 16650 default: 16651 // Do nothing and ignore the unexpected tag element 16652 err = decoder.Decoder.Skip() 16653 if err != nil { 16654 return err 16655 } 16656 16657 } 16658 decoder = originalDecoder 16659 } 16660 *v = sv 16661 return nil 16662} 16663 16664func awsRestxml_deserializeDocumentNotificationConfigurationFilter(v **types.NotificationConfigurationFilter, decoder smithyxml.NodeDecoder) error { 16665 if v == nil { 16666 return fmt.Errorf("unexpected nil of type %T", v) 16667 } 16668 var sv *types.NotificationConfigurationFilter 16669 if *v == nil { 16670 sv = &types.NotificationConfigurationFilter{} 16671 } else { 16672 sv = *v 16673 } 16674 16675 for { 16676 t, done, err := decoder.Token() 16677 if err != nil { 16678 return err 16679 } 16680 if done { 16681 break 16682 } 16683 originalDecoder := decoder 16684 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16685 switch { 16686 case strings.EqualFold("S3Key", t.Name.Local): 16687 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16688 if err := awsRestxml_deserializeDocumentS3KeyFilter(&sv.Key, nodeDecoder); err != nil { 16689 return err 16690 } 16691 16692 default: 16693 // Do nothing and ignore the unexpected tag element 16694 err = decoder.Decoder.Skip() 16695 if err != nil { 16696 return err 16697 } 16698 16699 } 16700 decoder = originalDecoder 16701 } 16702 *v = sv 16703 return nil 16704} 16705 16706func awsRestxml_deserializeDocumentObject(v **types.Object, decoder smithyxml.NodeDecoder) error { 16707 if v == nil { 16708 return fmt.Errorf("unexpected nil of type %T", v) 16709 } 16710 var sv *types.Object 16711 if *v == nil { 16712 sv = &types.Object{} 16713 } else { 16714 sv = *v 16715 } 16716 16717 for { 16718 t, done, err := decoder.Token() 16719 if err != nil { 16720 return err 16721 } 16722 if done { 16723 break 16724 } 16725 originalDecoder := decoder 16726 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16727 switch { 16728 case strings.EqualFold("ETag", t.Name.Local): 16729 val, err := decoder.Value() 16730 if err != nil { 16731 return err 16732 } 16733 if val == nil { 16734 break 16735 } 16736 { 16737 xtv := string(val) 16738 sv.ETag = ptr.String(xtv) 16739 } 16740 16741 case strings.EqualFold("Key", t.Name.Local): 16742 val, err := decoder.Value() 16743 if err != nil { 16744 return err 16745 } 16746 if val == nil { 16747 break 16748 } 16749 { 16750 xtv := string(val) 16751 sv.Key = ptr.String(xtv) 16752 } 16753 16754 case strings.EqualFold("LastModified", t.Name.Local): 16755 val, err := decoder.Value() 16756 if err != nil { 16757 return err 16758 } 16759 if val == nil { 16760 break 16761 } 16762 { 16763 xtv := string(val) 16764 t, err := smithytime.ParseDateTime(xtv) 16765 if err != nil { 16766 return err 16767 } 16768 sv.LastModified = ptr.Time(t) 16769 } 16770 16771 case strings.EqualFold("Owner", t.Name.Local): 16772 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16773 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 16774 return err 16775 } 16776 16777 case strings.EqualFold("Size", t.Name.Local): 16778 val, err := decoder.Value() 16779 if err != nil { 16780 return err 16781 } 16782 if val == nil { 16783 break 16784 } 16785 { 16786 xtv := string(val) 16787 i64, err := strconv.ParseInt(xtv, 10, 64) 16788 if err != nil { 16789 return err 16790 } 16791 sv.Size = i64 16792 } 16793 16794 case strings.EqualFold("StorageClass", t.Name.Local): 16795 val, err := decoder.Value() 16796 if err != nil { 16797 return err 16798 } 16799 if val == nil { 16800 break 16801 } 16802 { 16803 xtv := string(val) 16804 sv.StorageClass = types.ObjectStorageClass(xtv) 16805 } 16806 16807 default: 16808 // Do nothing and ignore the unexpected tag element 16809 err = decoder.Decoder.Skip() 16810 if err != nil { 16811 return err 16812 } 16813 16814 } 16815 decoder = originalDecoder 16816 } 16817 *v = sv 16818 return nil 16819} 16820 16821func awsRestxml_deserializeDocumentObjectAlreadyInActiveTierError(v **types.ObjectAlreadyInActiveTierError, decoder smithyxml.NodeDecoder) error { 16822 if v == nil { 16823 return fmt.Errorf("unexpected nil of type %T", v) 16824 } 16825 var sv *types.ObjectAlreadyInActiveTierError 16826 if *v == nil { 16827 sv = &types.ObjectAlreadyInActiveTierError{} 16828 } else { 16829 sv = *v 16830 } 16831 16832 for { 16833 t, done, err := decoder.Token() 16834 if err != nil { 16835 return err 16836 } 16837 if done { 16838 break 16839 } 16840 originalDecoder := decoder 16841 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16842 switch { 16843 default: 16844 // Do nothing and ignore the unexpected tag element 16845 err = decoder.Decoder.Skip() 16846 if err != nil { 16847 return err 16848 } 16849 16850 } 16851 decoder = originalDecoder 16852 } 16853 *v = sv 16854 return nil 16855} 16856 16857func awsRestxml_deserializeDocumentObjectList(v *[]types.Object, decoder smithyxml.NodeDecoder) error { 16858 if v == nil { 16859 return fmt.Errorf("unexpected nil of type %T", v) 16860 } 16861 var sv []types.Object 16862 if *v == nil { 16863 sv = make([]types.Object, 0) 16864 } else { 16865 sv = *v 16866 } 16867 16868 originalDecoder := decoder 16869 for { 16870 t, done, err := decoder.Token() 16871 if err != nil { 16872 return err 16873 } 16874 if done { 16875 break 16876 } 16877 switch { 16878 case strings.EqualFold("member", t.Name.Local): 16879 var col types.Object 16880 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16881 destAddr := &col 16882 if err := awsRestxml_deserializeDocumentObject(&destAddr, nodeDecoder); err != nil { 16883 return err 16884 } 16885 col = *destAddr 16886 sv = append(sv, col) 16887 16888 default: 16889 err = decoder.Decoder.Skip() 16890 if err != nil { 16891 return err 16892 } 16893 16894 } 16895 decoder = originalDecoder 16896 } 16897 *v = sv 16898 return nil 16899} 16900 16901func awsRestxml_deserializeDocumentObjectListUnwrapped(v *[]types.Object, decoder smithyxml.NodeDecoder) error { 16902 var sv []types.Object 16903 if *v == nil { 16904 sv = make([]types.Object, 0) 16905 } else { 16906 sv = *v 16907 } 16908 16909 switch { 16910 default: 16911 var mv types.Object 16912 t := decoder.StartEl 16913 _ = t 16914 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16915 destAddr := &mv 16916 if err := awsRestxml_deserializeDocumentObject(&destAddr, nodeDecoder); err != nil { 16917 return err 16918 } 16919 mv = *destAddr 16920 sv = append(sv, mv) 16921 } 16922 *v = sv 16923 return nil 16924} 16925func awsRestxml_deserializeDocumentObjectLockConfiguration(v **types.ObjectLockConfiguration, decoder smithyxml.NodeDecoder) error { 16926 if v == nil { 16927 return fmt.Errorf("unexpected nil of type %T", v) 16928 } 16929 var sv *types.ObjectLockConfiguration 16930 if *v == nil { 16931 sv = &types.ObjectLockConfiguration{} 16932 } else { 16933 sv = *v 16934 } 16935 16936 for { 16937 t, done, err := decoder.Token() 16938 if err != nil { 16939 return err 16940 } 16941 if done { 16942 break 16943 } 16944 originalDecoder := decoder 16945 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16946 switch { 16947 case strings.EqualFold("ObjectLockEnabled", t.Name.Local): 16948 val, err := decoder.Value() 16949 if err != nil { 16950 return err 16951 } 16952 if val == nil { 16953 break 16954 } 16955 { 16956 xtv := string(val) 16957 sv.ObjectLockEnabled = types.ObjectLockEnabled(xtv) 16958 } 16959 16960 case strings.EqualFold("Rule", t.Name.Local): 16961 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16962 if err := awsRestxml_deserializeDocumentObjectLockRule(&sv.Rule, nodeDecoder); err != nil { 16963 return err 16964 } 16965 16966 default: 16967 // Do nothing and ignore the unexpected tag element 16968 err = decoder.Decoder.Skip() 16969 if err != nil { 16970 return err 16971 } 16972 16973 } 16974 decoder = originalDecoder 16975 } 16976 *v = sv 16977 return nil 16978} 16979 16980func awsRestxml_deserializeDocumentObjectLockLegalHold(v **types.ObjectLockLegalHold, decoder smithyxml.NodeDecoder) error { 16981 if v == nil { 16982 return fmt.Errorf("unexpected nil of type %T", v) 16983 } 16984 var sv *types.ObjectLockLegalHold 16985 if *v == nil { 16986 sv = &types.ObjectLockLegalHold{} 16987 } else { 16988 sv = *v 16989 } 16990 16991 for { 16992 t, done, err := decoder.Token() 16993 if err != nil { 16994 return err 16995 } 16996 if done { 16997 break 16998 } 16999 originalDecoder := decoder 17000 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17001 switch { 17002 case strings.EqualFold("Status", t.Name.Local): 17003 val, err := decoder.Value() 17004 if err != nil { 17005 return err 17006 } 17007 if val == nil { 17008 break 17009 } 17010 { 17011 xtv := string(val) 17012 sv.Status = types.ObjectLockLegalHoldStatus(xtv) 17013 } 17014 17015 default: 17016 // Do nothing and ignore the unexpected tag element 17017 err = decoder.Decoder.Skip() 17018 if err != nil { 17019 return err 17020 } 17021 17022 } 17023 decoder = originalDecoder 17024 } 17025 *v = sv 17026 return nil 17027} 17028 17029func awsRestxml_deserializeDocumentObjectLockRetention(v **types.ObjectLockRetention, decoder smithyxml.NodeDecoder) error { 17030 if v == nil { 17031 return fmt.Errorf("unexpected nil of type %T", v) 17032 } 17033 var sv *types.ObjectLockRetention 17034 if *v == nil { 17035 sv = &types.ObjectLockRetention{} 17036 } else { 17037 sv = *v 17038 } 17039 17040 for { 17041 t, done, err := decoder.Token() 17042 if err != nil { 17043 return err 17044 } 17045 if done { 17046 break 17047 } 17048 originalDecoder := decoder 17049 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17050 switch { 17051 case strings.EqualFold("Mode", t.Name.Local): 17052 val, err := decoder.Value() 17053 if err != nil { 17054 return err 17055 } 17056 if val == nil { 17057 break 17058 } 17059 { 17060 xtv := string(val) 17061 sv.Mode = types.ObjectLockRetentionMode(xtv) 17062 } 17063 17064 case strings.EqualFold("RetainUntilDate", t.Name.Local): 17065 val, err := decoder.Value() 17066 if err != nil { 17067 return err 17068 } 17069 if val == nil { 17070 break 17071 } 17072 { 17073 xtv := string(val) 17074 t, err := smithytime.ParseDateTime(xtv) 17075 if err != nil { 17076 return err 17077 } 17078 sv.RetainUntilDate = ptr.Time(t) 17079 } 17080 17081 default: 17082 // Do nothing and ignore the unexpected tag element 17083 err = decoder.Decoder.Skip() 17084 if err != nil { 17085 return err 17086 } 17087 17088 } 17089 decoder = originalDecoder 17090 } 17091 *v = sv 17092 return nil 17093} 17094 17095func awsRestxml_deserializeDocumentObjectLockRule(v **types.ObjectLockRule, decoder smithyxml.NodeDecoder) error { 17096 if v == nil { 17097 return fmt.Errorf("unexpected nil of type %T", v) 17098 } 17099 var sv *types.ObjectLockRule 17100 if *v == nil { 17101 sv = &types.ObjectLockRule{} 17102 } else { 17103 sv = *v 17104 } 17105 17106 for { 17107 t, done, err := decoder.Token() 17108 if err != nil { 17109 return err 17110 } 17111 if done { 17112 break 17113 } 17114 originalDecoder := decoder 17115 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17116 switch { 17117 case strings.EqualFold("DefaultRetention", t.Name.Local): 17118 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17119 if err := awsRestxml_deserializeDocumentDefaultRetention(&sv.DefaultRetention, nodeDecoder); err != nil { 17120 return err 17121 } 17122 17123 default: 17124 // Do nothing and ignore the unexpected tag element 17125 err = decoder.Decoder.Skip() 17126 if err != nil { 17127 return err 17128 } 17129 17130 } 17131 decoder = originalDecoder 17132 } 17133 *v = sv 17134 return nil 17135} 17136 17137func awsRestxml_deserializeDocumentObjectNotInActiveTierError(v **types.ObjectNotInActiveTierError, decoder smithyxml.NodeDecoder) error { 17138 if v == nil { 17139 return fmt.Errorf("unexpected nil of type %T", v) 17140 } 17141 var sv *types.ObjectNotInActiveTierError 17142 if *v == nil { 17143 sv = &types.ObjectNotInActiveTierError{} 17144 } else { 17145 sv = *v 17146 } 17147 17148 for { 17149 t, done, err := decoder.Token() 17150 if err != nil { 17151 return err 17152 } 17153 if done { 17154 break 17155 } 17156 originalDecoder := decoder 17157 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17158 switch { 17159 default: 17160 // Do nothing and ignore the unexpected tag element 17161 err = decoder.Decoder.Skip() 17162 if err != nil { 17163 return err 17164 } 17165 17166 } 17167 decoder = originalDecoder 17168 } 17169 *v = sv 17170 return nil 17171} 17172 17173func awsRestxml_deserializeDocumentObjectVersion(v **types.ObjectVersion, decoder smithyxml.NodeDecoder) error { 17174 if v == nil { 17175 return fmt.Errorf("unexpected nil of type %T", v) 17176 } 17177 var sv *types.ObjectVersion 17178 if *v == nil { 17179 sv = &types.ObjectVersion{} 17180 } else { 17181 sv = *v 17182 } 17183 17184 for { 17185 t, done, err := decoder.Token() 17186 if err != nil { 17187 return err 17188 } 17189 if done { 17190 break 17191 } 17192 originalDecoder := decoder 17193 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17194 switch { 17195 case strings.EqualFold("ETag", t.Name.Local): 17196 val, err := decoder.Value() 17197 if err != nil { 17198 return err 17199 } 17200 if val == nil { 17201 break 17202 } 17203 { 17204 xtv := string(val) 17205 sv.ETag = ptr.String(xtv) 17206 } 17207 17208 case strings.EqualFold("IsLatest", t.Name.Local): 17209 val, err := decoder.Value() 17210 if err != nil { 17211 return err 17212 } 17213 if val == nil { 17214 break 17215 } 17216 { 17217 xtv, err := strconv.ParseBool(string(val)) 17218 if err != nil { 17219 return fmt.Errorf("expected IsLatest to be of type *bool, got %T instead", val) 17220 } 17221 sv.IsLatest = xtv 17222 } 17223 17224 case strings.EqualFold("Key", t.Name.Local): 17225 val, err := decoder.Value() 17226 if err != nil { 17227 return err 17228 } 17229 if val == nil { 17230 break 17231 } 17232 { 17233 xtv := string(val) 17234 sv.Key = ptr.String(xtv) 17235 } 17236 17237 case strings.EqualFold("LastModified", t.Name.Local): 17238 val, err := decoder.Value() 17239 if err != nil { 17240 return err 17241 } 17242 if val == nil { 17243 break 17244 } 17245 { 17246 xtv := string(val) 17247 t, err := smithytime.ParseDateTime(xtv) 17248 if err != nil { 17249 return err 17250 } 17251 sv.LastModified = ptr.Time(t) 17252 } 17253 17254 case strings.EqualFold("Owner", t.Name.Local): 17255 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17256 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 17257 return err 17258 } 17259 17260 case strings.EqualFold("Size", t.Name.Local): 17261 val, err := decoder.Value() 17262 if err != nil { 17263 return err 17264 } 17265 if val == nil { 17266 break 17267 } 17268 { 17269 xtv := string(val) 17270 i64, err := strconv.ParseInt(xtv, 10, 64) 17271 if err != nil { 17272 return err 17273 } 17274 sv.Size = i64 17275 } 17276 17277 case strings.EqualFold("StorageClass", t.Name.Local): 17278 val, err := decoder.Value() 17279 if err != nil { 17280 return err 17281 } 17282 if val == nil { 17283 break 17284 } 17285 { 17286 xtv := string(val) 17287 sv.StorageClass = types.ObjectVersionStorageClass(xtv) 17288 } 17289 17290 case strings.EqualFold("VersionId", t.Name.Local): 17291 val, err := decoder.Value() 17292 if err != nil { 17293 return err 17294 } 17295 if val == nil { 17296 break 17297 } 17298 { 17299 xtv := string(val) 17300 sv.VersionId = ptr.String(xtv) 17301 } 17302 17303 default: 17304 // Do nothing and ignore the unexpected tag element 17305 err = decoder.Decoder.Skip() 17306 if err != nil { 17307 return err 17308 } 17309 17310 } 17311 decoder = originalDecoder 17312 } 17313 *v = sv 17314 return nil 17315} 17316 17317func awsRestxml_deserializeDocumentObjectVersionList(v *[]types.ObjectVersion, decoder smithyxml.NodeDecoder) error { 17318 if v == nil { 17319 return fmt.Errorf("unexpected nil of type %T", v) 17320 } 17321 var sv []types.ObjectVersion 17322 if *v == nil { 17323 sv = make([]types.ObjectVersion, 0) 17324 } else { 17325 sv = *v 17326 } 17327 17328 originalDecoder := decoder 17329 for { 17330 t, done, err := decoder.Token() 17331 if err != nil { 17332 return err 17333 } 17334 if done { 17335 break 17336 } 17337 switch { 17338 case strings.EqualFold("member", t.Name.Local): 17339 var col types.ObjectVersion 17340 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17341 destAddr := &col 17342 if err := awsRestxml_deserializeDocumentObjectVersion(&destAddr, nodeDecoder); err != nil { 17343 return err 17344 } 17345 col = *destAddr 17346 sv = append(sv, col) 17347 17348 default: 17349 err = decoder.Decoder.Skip() 17350 if err != nil { 17351 return err 17352 } 17353 17354 } 17355 decoder = originalDecoder 17356 } 17357 *v = sv 17358 return nil 17359} 17360 17361func awsRestxml_deserializeDocumentObjectVersionListUnwrapped(v *[]types.ObjectVersion, decoder smithyxml.NodeDecoder) error { 17362 var sv []types.ObjectVersion 17363 if *v == nil { 17364 sv = make([]types.ObjectVersion, 0) 17365 } else { 17366 sv = *v 17367 } 17368 17369 switch { 17370 default: 17371 var mv types.ObjectVersion 17372 t := decoder.StartEl 17373 _ = t 17374 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17375 destAddr := &mv 17376 if err := awsRestxml_deserializeDocumentObjectVersion(&destAddr, nodeDecoder); err != nil { 17377 return err 17378 } 17379 mv = *destAddr 17380 sv = append(sv, mv) 17381 } 17382 *v = sv 17383 return nil 17384} 17385func awsRestxml_deserializeDocumentOwner(v **types.Owner, decoder smithyxml.NodeDecoder) error { 17386 if v == nil { 17387 return fmt.Errorf("unexpected nil of type %T", v) 17388 } 17389 var sv *types.Owner 17390 if *v == nil { 17391 sv = &types.Owner{} 17392 } else { 17393 sv = *v 17394 } 17395 17396 for { 17397 t, done, err := decoder.Token() 17398 if err != nil { 17399 return err 17400 } 17401 if done { 17402 break 17403 } 17404 originalDecoder := decoder 17405 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17406 switch { 17407 case strings.EqualFold("DisplayName", t.Name.Local): 17408 val, err := decoder.Value() 17409 if err != nil { 17410 return err 17411 } 17412 if val == nil { 17413 break 17414 } 17415 { 17416 xtv := string(val) 17417 sv.DisplayName = ptr.String(xtv) 17418 } 17419 17420 case strings.EqualFold("ID", t.Name.Local): 17421 val, err := decoder.Value() 17422 if err != nil { 17423 return err 17424 } 17425 if val == nil { 17426 break 17427 } 17428 { 17429 xtv := string(val) 17430 sv.ID = ptr.String(xtv) 17431 } 17432 17433 default: 17434 // Do nothing and ignore the unexpected tag element 17435 err = decoder.Decoder.Skip() 17436 if err != nil { 17437 return err 17438 } 17439 17440 } 17441 decoder = originalDecoder 17442 } 17443 *v = sv 17444 return nil 17445} 17446 17447func awsRestxml_deserializeDocumentOwnershipControls(v **types.OwnershipControls, decoder smithyxml.NodeDecoder) error { 17448 if v == nil { 17449 return fmt.Errorf("unexpected nil of type %T", v) 17450 } 17451 var sv *types.OwnershipControls 17452 if *v == nil { 17453 sv = &types.OwnershipControls{} 17454 } else { 17455 sv = *v 17456 } 17457 17458 for { 17459 t, done, err := decoder.Token() 17460 if err != nil { 17461 return err 17462 } 17463 if done { 17464 break 17465 } 17466 originalDecoder := decoder 17467 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17468 switch { 17469 case strings.EqualFold("Rule", t.Name.Local): 17470 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17471 if err := awsRestxml_deserializeDocumentOwnershipControlsRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 17472 return err 17473 } 17474 17475 default: 17476 // Do nothing and ignore the unexpected tag element 17477 err = decoder.Decoder.Skip() 17478 if err != nil { 17479 return err 17480 } 17481 17482 } 17483 decoder = originalDecoder 17484 } 17485 *v = sv 17486 return nil 17487} 17488 17489func awsRestxml_deserializeDocumentOwnershipControlsRule(v **types.OwnershipControlsRule, decoder smithyxml.NodeDecoder) error { 17490 if v == nil { 17491 return fmt.Errorf("unexpected nil of type %T", v) 17492 } 17493 var sv *types.OwnershipControlsRule 17494 if *v == nil { 17495 sv = &types.OwnershipControlsRule{} 17496 } else { 17497 sv = *v 17498 } 17499 17500 for { 17501 t, done, err := decoder.Token() 17502 if err != nil { 17503 return err 17504 } 17505 if done { 17506 break 17507 } 17508 originalDecoder := decoder 17509 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17510 switch { 17511 case strings.EqualFold("ObjectOwnership", t.Name.Local): 17512 val, err := decoder.Value() 17513 if err != nil { 17514 return err 17515 } 17516 if val == nil { 17517 break 17518 } 17519 { 17520 xtv := string(val) 17521 sv.ObjectOwnership = types.ObjectOwnership(xtv) 17522 } 17523 17524 default: 17525 // Do nothing and ignore the unexpected tag element 17526 err = decoder.Decoder.Skip() 17527 if err != nil { 17528 return err 17529 } 17530 17531 } 17532 decoder = originalDecoder 17533 } 17534 *v = sv 17535 return nil 17536} 17537 17538func awsRestxml_deserializeDocumentOwnershipControlsRules(v *[]types.OwnershipControlsRule, decoder smithyxml.NodeDecoder) error { 17539 if v == nil { 17540 return fmt.Errorf("unexpected nil of type %T", v) 17541 } 17542 var sv []types.OwnershipControlsRule 17543 if *v == nil { 17544 sv = make([]types.OwnershipControlsRule, 0) 17545 } else { 17546 sv = *v 17547 } 17548 17549 originalDecoder := decoder 17550 for { 17551 t, done, err := decoder.Token() 17552 if err != nil { 17553 return err 17554 } 17555 if done { 17556 break 17557 } 17558 switch { 17559 case strings.EqualFold("member", t.Name.Local): 17560 var col types.OwnershipControlsRule 17561 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17562 destAddr := &col 17563 if err := awsRestxml_deserializeDocumentOwnershipControlsRule(&destAddr, nodeDecoder); err != nil { 17564 return err 17565 } 17566 col = *destAddr 17567 sv = append(sv, col) 17568 17569 default: 17570 err = decoder.Decoder.Skip() 17571 if err != nil { 17572 return err 17573 } 17574 17575 } 17576 decoder = originalDecoder 17577 } 17578 *v = sv 17579 return nil 17580} 17581 17582func awsRestxml_deserializeDocumentOwnershipControlsRulesUnwrapped(v *[]types.OwnershipControlsRule, decoder smithyxml.NodeDecoder) error { 17583 var sv []types.OwnershipControlsRule 17584 if *v == nil { 17585 sv = make([]types.OwnershipControlsRule, 0) 17586 } else { 17587 sv = *v 17588 } 17589 17590 switch { 17591 default: 17592 var mv types.OwnershipControlsRule 17593 t := decoder.StartEl 17594 _ = t 17595 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17596 destAddr := &mv 17597 if err := awsRestxml_deserializeDocumentOwnershipControlsRule(&destAddr, nodeDecoder); err != nil { 17598 return err 17599 } 17600 mv = *destAddr 17601 sv = append(sv, mv) 17602 } 17603 *v = sv 17604 return nil 17605} 17606func awsRestxml_deserializeDocumentPart(v **types.Part, decoder smithyxml.NodeDecoder) error { 17607 if v == nil { 17608 return fmt.Errorf("unexpected nil of type %T", v) 17609 } 17610 var sv *types.Part 17611 if *v == nil { 17612 sv = &types.Part{} 17613 } else { 17614 sv = *v 17615 } 17616 17617 for { 17618 t, done, err := decoder.Token() 17619 if err != nil { 17620 return err 17621 } 17622 if done { 17623 break 17624 } 17625 originalDecoder := decoder 17626 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17627 switch { 17628 case strings.EqualFold("ETag", t.Name.Local): 17629 val, err := decoder.Value() 17630 if err != nil { 17631 return err 17632 } 17633 if val == nil { 17634 break 17635 } 17636 { 17637 xtv := string(val) 17638 sv.ETag = ptr.String(xtv) 17639 } 17640 17641 case strings.EqualFold("LastModified", t.Name.Local): 17642 val, err := decoder.Value() 17643 if err != nil { 17644 return err 17645 } 17646 if val == nil { 17647 break 17648 } 17649 { 17650 xtv := string(val) 17651 t, err := smithytime.ParseDateTime(xtv) 17652 if err != nil { 17653 return err 17654 } 17655 sv.LastModified = ptr.Time(t) 17656 } 17657 17658 case strings.EqualFold("PartNumber", t.Name.Local): 17659 val, err := decoder.Value() 17660 if err != nil { 17661 return err 17662 } 17663 if val == nil { 17664 break 17665 } 17666 { 17667 xtv := string(val) 17668 i64, err := strconv.ParseInt(xtv, 10, 64) 17669 if err != nil { 17670 return err 17671 } 17672 sv.PartNumber = int32(i64) 17673 } 17674 17675 case strings.EqualFold("Size", t.Name.Local): 17676 val, err := decoder.Value() 17677 if err != nil { 17678 return err 17679 } 17680 if val == nil { 17681 break 17682 } 17683 { 17684 xtv := string(val) 17685 i64, err := strconv.ParseInt(xtv, 10, 64) 17686 if err != nil { 17687 return err 17688 } 17689 sv.Size = i64 17690 } 17691 17692 default: 17693 // Do nothing and ignore the unexpected tag element 17694 err = decoder.Decoder.Skip() 17695 if err != nil { 17696 return err 17697 } 17698 17699 } 17700 decoder = originalDecoder 17701 } 17702 *v = sv 17703 return nil 17704} 17705 17706func awsRestxml_deserializeDocumentParts(v *[]types.Part, decoder smithyxml.NodeDecoder) error { 17707 if v == nil { 17708 return fmt.Errorf("unexpected nil of type %T", v) 17709 } 17710 var sv []types.Part 17711 if *v == nil { 17712 sv = make([]types.Part, 0) 17713 } else { 17714 sv = *v 17715 } 17716 17717 originalDecoder := decoder 17718 for { 17719 t, done, err := decoder.Token() 17720 if err != nil { 17721 return err 17722 } 17723 if done { 17724 break 17725 } 17726 switch { 17727 case strings.EqualFold("member", t.Name.Local): 17728 var col types.Part 17729 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17730 destAddr := &col 17731 if err := awsRestxml_deserializeDocumentPart(&destAddr, nodeDecoder); err != nil { 17732 return err 17733 } 17734 col = *destAddr 17735 sv = append(sv, col) 17736 17737 default: 17738 err = decoder.Decoder.Skip() 17739 if err != nil { 17740 return err 17741 } 17742 17743 } 17744 decoder = originalDecoder 17745 } 17746 *v = sv 17747 return nil 17748} 17749 17750func awsRestxml_deserializeDocumentPartsUnwrapped(v *[]types.Part, decoder smithyxml.NodeDecoder) error { 17751 var sv []types.Part 17752 if *v == nil { 17753 sv = make([]types.Part, 0) 17754 } else { 17755 sv = *v 17756 } 17757 17758 switch { 17759 default: 17760 var mv types.Part 17761 t := decoder.StartEl 17762 _ = t 17763 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17764 destAddr := &mv 17765 if err := awsRestxml_deserializeDocumentPart(&destAddr, nodeDecoder); err != nil { 17766 return err 17767 } 17768 mv = *destAddr 17769 sv = append(sv, mv) 17770 } 17771 *v = sv 17772 return nil 17773} 17774func awsRestxml_deserializeDocumentPolicyStatus(v **types.PolicyStatus, decoder smithyxml.NodeDecoder) error { 17775 if v == nil { 17776 return fmt.Errorf("unexpected nil of type %T", v) 17777 } 17778 var sv *types.PolicyStatus 17779 if *v == nil { 17780 sv = &types.PolicyStatus{} 17781 } else { 17782 sv = *v 17783 } 17784 17785 for { 17786 t, done, err := decoder.Token() 17787 if err != nil { 17788 return err 17789 } 17790 if done { 17791 break 17792 } 17793 originalDecoder := decoder 17794 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17795 switch { 17796 case strings.EqualFold("IsPublic", t.Name.Local): 17797 val, err := decoder.Value() 17798 if err != nil { 17799 return err 17800 } 17801 if val == nil { 17802 break 17803 } 17804 { 17805 xtv, err := strconv.ParseBool(string(val)) 17806 if err != nil { 17807 return fmt.Errorf("expected IsPublic to be of type *bool, got %T instead", val) 17808 } 17809 sv.IsPublic = xtv 17810 } 17811 17812 default: 17813 // Do nothing and ignore the unexpected tag element 17814 err = decoder.Decoder.Skip() 17815 if err != nil { 17816 return err 17817 } 17818 17819 } 17820 decoder = originalDecoder 17821 } 17822 *v = sv 17823 return nil 17824} 17825 17826func awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(v **types.PublicAccessBlockConfiguration, decoder smithyxml.NodeDecoder) error { 17827 if v == nil { 17828 return fmt.Errorf("unexpected nil of type %T", v) 17829 } 17830 var sv *types.PublicAccessBlockConfiguration 17831 if *v == nil { 17832 sv = &types.PublicAccessBlockConfiguration{} 17833 } else { 17834 sv = *v 17835 } 17836 17837 for { 17838 t, done, err := decoder.Token() 17839 if err != nil { 17840 return err 17841 } 17842 if done { 17843 break 17844 } 17845 originalDecoder := decoder 17846 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17847 switch { 17848 case strings.EqualFold("BlockPublicAcls", t.Name.Local): 17849 val, err := decoder.Value() 17850 if err != nil { 17851 return err 17852 } 17853 if val == nil { 17854 break 17855 } 17856 { 17857 xtv, err := strconv.ParseBool(string(val)) 17858 if err != nil { 17859 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17860 } 17861 sv.BlockPublicAcls = xtv 17862 } 17863 17864 case strings.EqualFold("BlockPublicPolicy", t.Name.Local): 17865 val, err := decoder.Value() 17866 if err != nil { 17867 return err 17868 } 17869 if val == nil { 17870 break 17871 } 17872 { 17873 xtv, err := strconv.ParseBool(string(val)) 17874 if err != nil { 17875 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17876 } 17877 sv.BlockPublicPolicy = xtv 17878 } 17879 17880 case strings.EqualFold("IgnorePublicAcls", t.Name.Local): 17881 val, err := decoder.Value() 17882 if err != nil { 17883 return err 17884 } 17885 if val == nil { 17886 break 17887 } 17888 { 17889 xtv, err := strconv.ParseBool(string(val)) 17890 if err != nil { 17891 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17892 } 17893 sv.IgnorePublicAcls = xtv 17894 } 17895 17896 case strings.EqualFold("RestrictPublicBuckets", t.Name.Local): 17897 val, err := decoder.Value() 17898 if err != nil { 17899 return err 17900 } 17901 if val == nil { 17902 break 17903 } 17904 { 17905 xtv, err := strconv.ParseBool(string(val)) 17906 if err != nil { 17907 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17908 } 17909 sv.RestrictPublicBuckets = xtv 17910 } 17911 17912 default: 17913 // Do nothing and ignore the unexpected tag element 17914 err = decoder.Decoder.Skip() 17915 if err != nil { 17916 return err 17917 } 17918 17919 } 17920 decoder = originalDecoder 17921 } 17922 *v = sv 17923 return nil 17924} 17925 17926func awsRestxml_deserializeDocumentQueueConfiguration(v **types.QueueConfiguration, decoder smithyxml.NodeDecoder) error { 17927 if v == nil { 17928 return fmt.Errorf("unexpected nil of type %T", v) 17929 } 17930 var sv *types.QueueConfiguration 17931 if *v == nil { 17932 sv = &types.QueueConfiguration{} 17933 } else { 17934 sv = *v 17935 } 17936 17937 for { 17938 t, done, err := decoder.Token() 17939 if err != nil { 17940 return err 17941 } 17942 if done { 17943 break 17944 } 17945 originalDecoder := decoder 17946 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17947 switch { 17948 case strings.EqualFold("Event", t.Name.Local): 17949 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17950 if err := awsRestxml_deserializeDocumentEventListUnwrapped(&sv.Events, nodeDecoder); err != nil { 17951 return err 17952 } 17953 17954 case strings.EqualFold("Filter", t.Name.Local): 17955 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17956 if err := awsRestxml_deserializeDocumentNotificationConfigurationFilter(&sv.Filter, nodeDecoder); err != nil { 17957 return err 17958 } 17959 17960 case strings.EqualFold("Id", t.Name.Local): 17961 val, err := decoder.Value() 17962 if err != nil { 17963 return err 17964 } 17965 if val == nil { 17966 break 17967 } 17968 { 17969 xtv := string(val) 17970 sv.Id = ptr.String(xtv) 17971 } 17972 17973 case strings.EqualFold("Queue", t.Name.Local): 17974 val, err := decoder.Value() 17975 if err != nil { 17976 return err 17977 } 17978 if val == nil { 17979 break 17980 } 17981 { 17982 xtv := string(val) 17983 sv.QueueArn = ptr.String(xtv) 17984 } 17985 17986 default: 17987 // Do nothing and ignore the unexpected tag element 17988 err = decoder.Decoder.Skip() 17989 if err != nil { 17990 return err 17991 } 17992 17993 } 17994 decoder = originalDecoder 17995 } 17996 *v = sv 17997 return nil 17998} 17999 18000func awsRestxml_deserializeDocumentQueueConfigurationList(v *[]types.QueueConfiguration, decoder smithyxml.NodeDecoder) error { 18001 if v == nil { 18002 return fmt.Errorf("unexpected nil of type %T", v) 18003 } 18004 var sv []types.QueueConfiguration 18005 if *v == nil { 18006 sv = make([]types.QueueConfiguration, 0) 18007 } else { 18008 sv = *v 18009 } 18010 18011 originalDecoder := decoder 18012 for { 18013 t, done, err := decoder.Token() 18014 if err != nil { 18015 return err 18016 } 18017 if done { 18018 break 18019 } 18020 switch { 18021 case strings.EqualFold("member", t.Name.Local): 18022 var col types.QueueConfiguration 18023 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18024 destAddr := &col 18025 if err := awsRestxml_deserializeDocumentQueueConfiguration(&destAddr, nodeDecoder); err != nil { 18026 return err 18027 } 18028 col = *destAddr 18029 sv = append(sv, col) 18030 18031 default: 18032 err = decoder.Decoder.Skip() 18033 if err != nil { 18034 return err 18035 } 18036 18037 } 18038 decoder = originalDecoder 18039 } 18040 *v = sv 18041 return nil 18042} 18043 18044func awsRestxml_deserializeDocumentQueueConfigurationListUnwrapped(v *[]types.QueueConfiguration, decoder smithyxml.NodeDecoder) error { 18045 var sv []types.QueueConfiguration 18046 if *v == nil { 18047 sv = make([]types.QueueConfiguration, 0) 18048 } else { 18049 sv = *v 18050 } 18051 18052 switch { 18053 default: 18054 var mv types.QueueConfiguration 18055 t := decoder.StartEl 18056 _ = t 18057 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18058 destAddr := &mv 18059 if err := awsRestxml_deserializeDocumentQueueConfiguration(&destAddr, nodeDecoder); err != nil { 18060 return err 18061 } 18062 mv = *destAddr 18063 sv = append(sv, mv) 18064 } 18065 *v = sv 18066 return nil 18067} 18068func awsRestxml_deserializeDocumentRedirect(v **types.Redirect, decoder smithyxml.NodeDecoder) error { 18069 if v == nil { 18070 return fmt.Errorf("unexpected nil of type %T", v) 18071 } 18072 var sv *types.Redirect 18073 if *v == nil { 18074 sv = &types.Redirect{} 18075 } else { 18076 sv = *v 18077 } 18078 18079 for { 18080 t, done, err := decoder.Token() 18081 if err != nil { 18082 return err 18083 } 18084 if done { 18085 break 18086 } 18087 originalDecoder := decoder 18088 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18089 switch { 18090 case strings.EqualFold("HostName", t.Name.Local): 18091 val, err := decoder.Value() 18092 if err != nil { 18093 return err 18094 } 18095 if val == nil { 18096 break 18097 } 18098 { 18099 xtv := string(val) 18100 sv.HostName = ptr.String(xtv) 18101 } 18102 18103 case strings.EqualFold("HttpRedirectCode", t.Name.Local): 18104 val, err := decoder.Value() 18105 if err != nil { 18106 return err 18107 } 18108 if val == nil { 18109 break 18110 } 18111 { 18112 xtv := string(val) 18113 sv.HttpRedirectCode = ptr.String(xtv) 18114 } 18115 18116 case strings.EqualFold("Protocol", t.Name.Local): 18117 val, err := decoder.Value() 18118 if err != nil { 18119 return err 18120 } 18121 if val == nil { 18122 break 18123 } 18124 { 18125 xtv := string(val) 18126 sv.Protocol = types.Protocol(xtv) 18127 } 18128 18129 case strings.EqualFold("ReplaceKeyPrefixWith", t.Name.Local): 18130 val, err := decoder.Value() 18131 if err != nil { 18132 return err 18133 } 18134 if val == nil { 18135 break 18136 } 18137 { 18138 xtv := string(val) 18139 sv.ReplaceKeyPrefixWith = ptr.String(xtv) 18140 } 18141 18142 case strings.EqualFold("ReplaceKeyWith", t.Name.Local): 18143 val, err := decoder.Value() 18144 if err != nil { 18145 return err 18146 } 18147 if val == nil { 18148 break 18149 } 18150 { 18151 xtv := string(val) 18152 sv.ReplaceKeyWith = ptr.String(xtv) 18153 } 18154 18155 default: 18156 // Do nothing and ignore the unexpected tag element 18157 err = decoder.Decoder.Skip() 18158 if err != nil { 18159 return err 18160 } 18161 18162 } 18163 decoder = originalDecoder 18164 } 18165 *v = sv 18166 return nil 18167} 18168 18169func awsRestxml_deserializeDocumentRedirectAllRequestsTo(v **types.RedirectAllRequestsTo, decoder smithyxml.NodeDecoder) error { 18170 if v == nil { 18171 return fmt.Errorf("unexpected nil of type %T", v) 18172 } 18173 var sv *types.RedirectAllRequestsTo 18174 if *v == nil { 18175 sv = &types.RedirectAllRequestsTo{} 18176 } else { 18177 sv = *v 18178 } 18179 18180 for { 18181 t, done, err := decoder.Token() 18182 if err != nil { 18183 return err 18184 } 18185 if done { 18186 break 18187 } 18188 originalDecoder := decoder 18189 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18190 switch { 18191 case strings.EqualFold("HostName", t.Name.Local): 18192 val, err := decoder.Value() 18193 if err != nil { 18194 return err 18195 } 18196 if val == nil { 18197 break 18198 } 18199 { 18200 xtv := string(val) 18201 sv.HostName = ptr.String(xtv) 18202 } 18203 18204 case strings.EqualFold("Protocol", t.Name.Local): 18205 val, err := decoder.Value() 18206 if err != nil { 18207 return err 18208 } 18209 if val == nil { 18210 break 18211 } 18212 { 18213 xtv := string(val) 18214 sv.Protocol = types.Protocol(xtv) 18215 } 18216 18217 default: 18218 // Do nothing and ignore the unexpected tag element 18219 err = decoder.Decoder.Skip() 18220 if err != nil { 18221 return err 18222 } 18223 18224 } 18225 decoder = originalDecoder 18226 } 18227 *v = sv 18228 return nil 18229} 18230 18231func awsRestxml_deserializeDocumentReplicaModifications(v **types.ReplicaModifications, decoder smithyxml.NodeDecoder) error { 18232 if v == nil { 18233 return fmt.Errorf("unexpected nil of type %T", v) 18234 } 18235 var sv *types.ReplicaModifications 18236 if *v == nil { 18237 sv = &types.ReplicaModifications{} 18238 } else { 18239 sv = *v 18240 } 18241 18242 for { 18243 t, done, err := decoder.Token() 18244 if err != nil { 18245 return err 18246 } 18247 if done { 18248 break 18249 } 18250 originalDecoder := decoder 18251 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18252 switch { 18253 case strings.EqualFold("Status", t.Name.Local): 18254 val, err := decoder.Value() 18255 if err != nil { 18256 return err 18257 } 18258 if val == nil { 18259 break 18260 } 18261 { 18262 xtv := string(val) 18263 sv.Status = types.ReplicaModificationsStatus(xtv) 18264 } 18265 18266 default: 18267 // Do nothing and ignore the unexpected tag element 18268 err = decoder.Decoder.Skip() 18269 if err != nil { 18270 return err 18271 } 18272 18273 } 18274 decoder = originalDecoder 18275 } 18276 *v = sv 18277 return nil 18278} 18279 18280func awsRestxml_deserializeDocumentReplicationConfiguration(v **types.ReplicationConfiguration, decoder smithyxml.NodeDecoder) error { 18281 if v == nil { 18282 return fmt.Errorf("unexpected nil of type %T", v) 18283 } 18284 var sv *types.ReplicationConfiguration 18285 if *v == nil { 18286 sv = &types.ReplicationConfiguration{} 18287 } else { 18288 sv = *v 18289 } 18290 18291 for { 18292 t, done, err := decoder.Token() 18293 if err != nil { 18294 return err 18295 } 18296 if done { 18297 break 18298 } 18299 originalDecoder := decoder 18300 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18301 switch { 18302 case strings.EqualFold("Role", t.Name.Local): 18303 val, err := decoder.Value() 18304 if err != nil { 18305 return err 18306 } 18307 if val == nil { 18308 break 18309 } 18310 { 18311 xtv := string(val) 18312 sv.Role = ptr.String(xtv) 18313 } 18314 18315 case strings.EqualFold("Rule", t.Name.Local): 18316 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18317 if err := awsRestxml_deserializeDocumentReplicationRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 18318 return err 18319 } 18320 18321 default: 18322 // Do nothing and ignore the unexpected tag element 18323 err = decoder.Decoder.Skip() 18324 if err != nil { 18325 return err 18326 } 18327 18328 } 18329 decoder = originalDecoder 18330 } 18331 *v = sv 18332 return nil 18333} 18334 18335func awsRestxml_deserializeDocumentReplicationRule(v **types.ReplicationRule, decoder smithyxml.NodeDecoder) error { 18336 if v == nil { 18337 return fmt.Errorf("unexpected nil of type %T", v) 18338 } 18339 var sv *types.ReplicationRule 18340 if *v == nil { 18341 sv = &types.ReplicationRule{} 18342 } else { 18343 sv = *v 18344 } 18345 18346 for { 18347 t, done, err := decoder.Token() 18348 if err != nil { 18349 return err 18350 } 18351 if done { 18352 break 18353 } 18354 originalDecoder := decoder 18355 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18356 switch { 18357 case strings.EqualFold("DeleteMarkerReplication", t.Name.Local): 18358 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18359 if err := awsRestxml_deserializeDocumentDeleteMarkerReplication(&sv.DeleteMarkerReplication, nodeDecoder); err != nil { 18360 return err 18361 } 18362 18363 case strings.EqualFold("Destination", t.Name.Local): 18364 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18365 if err := awsRestxml_deserializeDocumentDestination(&sv.Destination, nodeDecoder); err != nil { 18366 return err 18367 } 18368 18369 case strings.EqualFold("ExistingObjectReplication", t.Name.Local): 18370 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18371 if err := awsRestxml_deserializeDocumentExistingObjectReplication(&sv.ExistingObjectReplication, nodeDecoder); err != nil { 18372 return err 18373 } 18374 18375 case strings.EqualFold("Filter", t.Name.Local): 18376 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18377 if err := awsRestxml_deserializeDocumentReplicationRuleFilter(&sv.Filter, nodeDecoder); err != nil { 18378 return err 18379 } 18380 18381 case strings.EqualFold("ID", t.Name.Local): 18382 val, err := decoder.Value() 18383 if err != nil { 18384 return err 18385 } 18386 if val == nil { 18387 break 18388 } 18389 { 18390 xtv := string(val) 18391 sv.ID = ptr.String(xtv) 18392 } 18393 18394 case strings.EqualFold("Prefix", t.Name.Local): 18395 val, err := decoder.Value() 18396 if err != nil { 18397 return err 18398 } 18399 if val == nil { 18400 break 18401 } 18402 { 18403 xtv := string(val) 18404 sv.Prefix = ptr.String(xtv) 18405 } 18406 18407 case strings.EqualFold("Priority", t.Name.Local): 18408 val, err := decoder.Value() 18409 if err != nil { 18410 return err 18411 } 18412 if val == nil { 18413 break 18414 } 18415 { 18416 xtv := string(val) 18417 i64, err := strconv.ParseInt(xtv, 10, 64) 18418 if err != nil { 18419 return err 18420 } 18421 sv.Priority = int32(i64) 18422 } 18423 18424 case strings.EqualFold("SourceSelectionCriteria", t.Name.Local): 18425 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18426 if err := awsRestxml_deserializeDocumentSourceSelectionCriteria(&sv.SourceSelectionCriteria, nodeDecoder); err != nil { 18427 return err 18428 } 18429 18430 case strings.EqualFold("Status", t.Name.Local): 18431 val, err := decoder.Value() 18432 if err != nil { 18433 return err 18434 } 18435 if val == nil { 18436 break 18437 } 18438 { 18439 xtv := string(val) 18440 sv.Status = types.ReplicationRuleStatus(xtv) 18441 } 18442 18443 default: 18444 // Do nothing and ignore the unexpected tag element 18445 err = decoder.Decoder.Skip() 18446 if err != nil { 18447 return err 18448 } 18449 18450 } 18451 decoder = originalDecoder 18452 } 18453 *v = sv 18454 return nil 18455} 18456 18457func awsRestxml_deserializeDocumentReplicationRuleAndOperator(v **types.ReplicationRuleAndOperator, decoder smithyxml.NodeDecoder) error { 18458 if v == nil { 18459 return fmt.Errorf("unexpected nil of type %T", v) 18460 } 18461 var sv *types.ReplicationRuleAndOperator 18462 if *v == nil { 18463 sv = &types.ReplicationRuleAndOperator{} 18464 } else { 18465 sv = *v 18466 } 18467 18468 for { 18469 t, done, err := decoder.Token() 18470 if err != nil { 18471 return err 18472 } 18473 if done { 18474 break 18475 } 18476 originalDecoder := decoder 18477 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18478 switch { 18479 case strings.EqualFold("Prefix", t.Name.Local): 18480 val, err := decoder.Value() 18481 if err != nil { 18482 return err 18483 } 18484 if val == nil { 18485 break 18486 } 18487 { 18488 xtv := string(val) 18489 sv.Prefix = ptr.String(xtv) 18490 } 18491 18492 case strings.EqualFold("Tag", t.Name.Local): 18493 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18494 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 18495 return err 18496 } 18497 18498 default: 18499 // Do nothing and ignore the unexpected tag element 18500 err = decoder.Decoder.Skip() 18501 if err != nil { 18502 return err 18503 } 18504 18505 } 18506 decoder = originalDecoder 18507 } 18508 *v = sv 18509 return nil 18510} 18511 18512func awsRestxml_deserializeDocumentReplicationRuleFilter(v *types.ReplicationRuleFilter, decoder smithyxml.NodeDecoder) error { 18513 if v == nil { 18514 return fmt.Errorf("unexpected nil of type %T", v) 18515 } 18516 var uv types.ReplicationRuleFilter 18517 var memberFound bool 18518 for { 18519 t, done, err := decoder.Token() 18520 if err != nil { 18521 return err 18522 } 18523 if done { 18524 break 18525 } 18526 if memberFound { 18527 if err = decoder.Decoder.Skip(); err != nil { 18528 return err 18529 } 18530 } 18531 originalDecoder := decoder 18532 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18533 switch { 18534 case strings.EqualFold("And", t.Name.Local): 18535 var mv types.ReplicationRuleAndOperator 18536 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18537 destAddr := &mv 18538 if err := awsRestxml_deserializeDocumentReplicationRuleAndOperator(&destAddr, nodeDecoder); err != nil { 18539 return err 18540 } 18541 mv = *destAddr 18542 uv = &types.ReplicationRuleFilterMemberAnd{Value: mv} 18543 memberFound = true 18544 18545 case strings.EqualFold("Prefix", t.Name.Local): 18546 var mv string 18547 val, err := decoder.Value() 18548 if err != nil { 18549 return err 18550 } 18551 if val == nil { 18552 break 18553 } 18554 { 18555 xtv := string(val) 18556 mv = xtv 18557 } 18558 uv = &types.ReplicationRuleFilterMemberPrefix{Value: mv} 18559 memberFound = true 18560 18561 case strings.EqualFold("Tag", t.Name.Local): 18562 var mv types.Tag 18563 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18564 destAddr := &mv 18565 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 18566 return err 18567 } 18568 mv = *destAddr 18569 uv = &types.ReplicationRuleFilterMemberTag{Value: mv} 18570 memberFound = true 18571 18572 default: 18573 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 18574 memberFound = true 18575 18576 } 18577 decoder = originalDecoder 18578 } 18579 *v = uv 18580 return nil 18581} 18582 18583func awsRestxml_deserializeDocumentReplicationRules(v *[]types.ReplicationRule, decoder smithyxml.NodeDecoder) error { 18584 if v == nil { 18585 return fmt.Errorf("unexpected nil of type %T", v) 18586 } 18587 var sv []types.ReplicationRule 18588 if *v == nil { 18589 sv = make([]types.ReplicationRule, 0) 18590 } else { 18591 sv = *v 18592 } 18593 18594 originalDecoder := decoder 18595 for { 18596 t, done, err := decoder.Token() 18597 if err != nil { 18598 return err 18599 } 18600 if done { 18601 break 18602 } 18603 switch { 18604 case strings.EqualFold("member", t.Name.Local): 18605 var col types.ReplicationRule 18606 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18607 destAddr := &col 18608 if err := awsRestxml_deserializeDocumentReplicationRule(&destAddr, nodeDecoder); err != nil { 18609 return err 18610 } 18611 col = *destAddr 18612 sv = append(sv, col) 18613 18614 default: 18615 err = decoder.Decoder.Skip() 18616 if err != nil { 18617 return err 18618 } 18619 18620 } 18621 decoder = originalDecoder 18622 } 18623 *v = sv 18624 return nil 18625} 18626 18627func awsRestxml_deserializeDocumentReplicationRulesUnwrapped(v *[]types.ReplicationRule, decoder smithyxml.NodeDecoder) error { 18628 var sv []types.ReplicationRule 18629 if *v == nil { 18630 sv = make([]types.ReplicationRule, 0) 18631 } else { 18632 sv = *v 18633 } 18634 18635 switch { 18636 default: 18637 var mv types.ReplicationRule 18638 t := decoder.StartEl 18639 _ = t 18640 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18641 destAddr := &mv 18642 if err := awsRestxml_deserializeDocumentReplicationRule(&destAddr, nodeDecoder); err != nil { 18643 return err 18644 } 18645 mv = *destAddr 18646 sv = append(sv, mv) 18647 } 18648 *v = sv 18649 return nil 18650} 18651func awsRestxml_deserializeDocumentReplicationTime(v **types.ReplicationTime, decoder smithyxml.NodeDecoder) error { 18652 if v == nil { 18653 return fmt.Errorf("unexpected nil of type %T", v) 18654 } 18655 var sv *types.ReplicationTime 18656 if *v == nil { 18657 sv = &types.ReplicationTime{} 18658 } else { 18659 sv = *v 18660 } 18661 18662 for { 18663 t, done, err := decoder.Token() 18664 if err != nil { 18665 return err 18666 } 18667 if done { 18668 break 18669 } 18670 originalDecoder := decoder 18671 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18672 switch { 18673 case strings.EqualFold("Status", t.Name.Local): 18674 val, err := decoder.Value() 18675 if err != nil { 18676 return err 18677 } 18678 if val == nil { 18679 break 18680 } 18681 { 18682 xtv := string(val) 18683 sv.Status = types.ReplicationTimeStatus(xtv) 18684 } 18685 18686 case strings.EqualFold("Time", t.Name.Local): 18687 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18688 if err := awsRestxml_deserializeDocumentReplicationTimeValue(&sv.Time, nodeDecoder); err != nil { 18689 return err 18690 } 18691 18692 default: 18693 // Do nothing and ignore the unexpected tag element 18694 err = decoder.Decoder.Skip() 18695 if err != nil { 18696 return err 18697 } 18698 18699 } 18700 decoder = originalDecoder 18701 } 18702 *v = sv 18703 return nil 18704} 18705 18706func awsRestxml_deserializeDocumentReplicationTimeValue(v **types.ReplicationTimeValue, decoder smithyxml.NodeDecoder) error { 18707 if v == nil { 18708 return fmt.Errorf("unexpected nil of type %T", v) 18709 } 18710 var sv *types.ReplicationTimeValue 18711 if *v == nil { 18712 sv = &types.ReplicationTimeValue{} 18713 } else { 18714 sv = *v 18715 } 18716 18717 for { 18718 t, done, err := decoder.Token() 18719 if err != nil { 18720 return err 18721 } 18722 if done { 18723 break 18724 } 18725 originalDecoder := decoder 18726 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18727 switch { 18728 case strings.EqualFold("Minutes", t.Name.Local): 18729 val, err := decoder.Value() 18730 if err != nil { 18731 return err 18732 } 18733 if val == nil { 18734 break 18735 } 18736 { 18737 xtv := string(val) 18738 i64, err := strconv.ParseInt(xtv, 10, 64) 18739 if err != nil { 18740 return err 18741 } 18742 sv.Minutes = int32(i64) 18743 } 18744 18745 default: 18746 // Do nothing and ignore the unexpected tag element 18747 err = decoder.Decoder.Skip() 18748 if err != nil { 18749 return err 18750 } 18751 18752 } 18753 decoder = originalDecoder 18754 } 18755 *v = sv 18756 return nil 18757} 18758 18759func awsRestxml_deserializeDocumentRoutingRule(v **types.RoutingRule, decoder smithyxml.NodeDecoder) error { 18760 if v == nil { 18761 return fmt.Errorf("unexpected nil of type %T", v) 18762 } 18763 var sv *types.RoutingRule 18764 if *v == nil { 18765 sv = &types.RoutingRule{} 18766 } else { 18767 sv = *v 18768 } 18769 18770 for { 18771 t, done, err := decoder.Token() 18772 if err != nil { 18773 return err 18774 } 18775 if done { 18776 break 18777 } 18778 originalDecoder := decoder 18779 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18780 switch { 18781 case strings.EqualFold("Condition", t.Name.Local): 18782 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18783 if err := awsRestxml_deserializeDocumentCondition(&sv.Condition, nodeDecoder); err != nil { 18784 return err 18785 } 18786 18787 case strings.EqualFold("Redirect", t.Name.Local): 18788 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18789 if err := awsRestxml_deserializeDocumentRedirect(&sv.Redirect, nodeDecoder); err != nil { 18790 return err 18791 } 18792 18793 default: 18794 // Do nothing and ignore the unexpected tag element 18795 err = decoder.Decoder.Skip() 18796 if err != nil { 18797 return err 18798 } 18799 18800 } 18801 decoder = originalDecoder 18802 } 18803 *v = sv 18804 return nil 18805} 18806 18807func awsRestxml_deserializeDocumentRoutingRules(v *[]types.RoutingRule, decoder smithyxml.NodeDecoder) error { 18808 if v == nil { 18809 return fmt.Errorf("unexpected nil of type %T", v) 18810 } 18811 var sv []types.RoutingRule 18812 if *v == nil { 18813 sv = make([]types.RoutingRule, 0) 18814 } else { 18815 sv = *v 18816 } 18817 18818 originalDecoder := decoder 18819 for { 18820 t, done, err := decoder.Token() 18821 if err != nil { 18822 return err 18823 } 18824 if done { 18825 break 18826 } 18827 switch { 18828 case strings.EqualFold("RoutingRule", t.Name.Local): 18829 var col types.RoutingRule 18830 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18831 destAddr := &col 18832 if err := awsRestxml_deserializeDocumentRoutingRule(&destAddr, nodeDecoder); err != nil { 18833 return err 18834 } 18835 col = *destAddr 18836 sv = append(sv, col) 18837 18838 default: 18839 err = decoder.Decoder.Skip() 18840 if err != nil { 18841 return err 18842 } 18843 18844 } 18845 decoder = originalDecoder 18846 } 18847 *v = sv 18848 return nil 18849} 18850 18851func awsRestxml_deserializeDocumentRoutingRulesUnwrapped(v *[]types.RoutingRule, decoder smithyxml.NodeDecoder) error { 18852 var sv []types.RoutingRule 18853 if *v == nil { 18854 sv = make([]types.RoutingRule, 0) 18855 } else { 18856 sv = *v 18857 } 18858 18859 switch { 18860 default: 18861 var mv types.RoutingRule 18862 t := decoder.StartEl 18863 _ = t 18864 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18865 destAddr := &mv 18866 if err := awsRestxml_deserializeDocumentRoutingRule(&destAddr, nodeDecoder); err != nil { 18867 return err 18868 } 18869 mv = *destAddr 18870 sv = append(sv, mv) 18871 } 18872 *v = sv 18873 return nil 18874} 18875func awsRestxml_deserializeDocumentS3KeyFilter(v **types.S3KeyFilter, decoder smithyxml.NodeDecoder) error { 18876 if v == nil { 18877 return fmt.Errorf("unexpected nil of type %T", v) 18878 } 18879 var sv *types.S3KeyFilter 18880 if *v == nil { 18881 sv = &types.S3KeyFilter{} 18882 } else { 18883 sv = *v 18884 } 18885 18886 for { 18887 t, done, err := decoder.Token() 18888 if err != nil { 18889 return err 18890 } 18891 if done { 18892 break 18893 } 18894 originalDecoder := decoder 18895 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18896 switch { 18897 case strings.EqualFold("FilterRule", t.Name.Local): 18898 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18899 if err := awsRestxml_deserializeDocumentFilterRuleListUnwrapped(&sv.FilterRules, nodeDecoder); err != nil { 18900 return err 18901 } 18902 18903 default: 18904 // Do nothing and ignore the unexpected tag element 18905 err = decoder.Decoder.Skip() 18906 if err != nil { 18907 return err 18908 } 18909 18910 } 18911 decoder = originalDecoder 18912 } 18913 *v = sv 18914 return nil 18915} 18916 18917func awsRestxml_deserializeDocumentServerSideEncryptionByDefault(v **types.ServerSideEncryptionByDefault, decoder smithyxml.NodeDecoder) error { 18918 if v == nil { 18919 return fmt.Errorf("unexpected nil of type %T", v) 18920 } 18921 var sv *types.ServerSideEncryptionByDefault 18922 if *v == nil { 18923 sv = &types.ServerSideEncryptionByDefault{} 18924 } else { 18925 sv = *v 18926 } 18927 18928 for { 18929 t, done, err := decoder.Token() 18930 if err != nil { 18931 return err 18932 } 18933 if done { 18934 break 18935 } 18936 originalDecoder := decoder 18937 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18938 switch { 18939 case strings.EqualFold("KMSMasterKeyID", t.Name.Local): 18940 val, err := decoder.Value() 18941 if err != nil { 18942 return err 18943 } 18944 if val == nil { 18945 break 18946 } 18947 { 18948 xtv := string(val) 18949 sv.KMSMasterKeyID = ptr.String(xtv) 18950 } 18951 18952 case strings.EqualFold("SSEAlgorithm", t.Name.Local): 18953 val, err := decoder.Value() 18954 if err != nil { 18955 return err 18956 } 18957 if val == nil { 18958 break 18959 } 18960 { 18961 xtv := string(val) 18962 sv.SSEAlgorithm = types.ServerSideEncryption(xtv) 18963 } 18964 18965 default: 18966 // Do nothing and ignore the unexpected tag element 18967 err = decoder.Decoder.Skip() 18968 if err != nil { 18969 return err 18970 } 18971 18972 } 18973 decoder = originalDecoder 18974 } 18975 *v = sv 18976 return nil 18977} 18978 18979func awsRestxml_deserializeDocumentServerSideEncryptionConfiguration(v **types.ServerSideEncryptionConfiguration, decoder smithyxml.NodeDecoder) error { 18980 if v == nil { 18981 return fmt.Errorf("unexpected nil of type %T", v) 18982 } 18983 var sv *types.ServerSideEncryptionConfiguration 18984 if *v == nil { 18985 sv = &types.ServerSideEncryptionConfiguration{} 18986 } else { 18987 sv = *v 18988 } 18989 18990 for { 18991 t, done, err := decoder.Token() 18992 if err != nil { 18993 return err 18994 } 18995 if done { 18996 break 18997 } 18998 originalDecoder := decoder 18999 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19000 switch { 19001 case strings.EqualFold("Rule", t.Name.Local): 19002 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19003 if err := awsRestxml_deserializeDocumentServerSideEncryptionRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 19004 return err 19005 } 19006 19007 default: 19008 // Do nothing and ignore the unexpected tag element 19009 err = decoder.Decoder.Skip() 19010 if err != nil { 19011 return err 19012 } 19013 19014 } 19015 decoder = originalDecoder 19016 } 19017 *v = sv 19018 return nil 19019} 19020 19021func awsRestxml_deserializeDocumentServerSideEncryptionRule(v **types.ServerSideEncryptionRule, decoder smithyxml.NodeDecoder) error { 19022 if v == nil { 19023 return fmt.Errorf("unexpected nil of type %T", v) 19024 } 19025 var sv *types.ServerSideEncryptionRule 19026 if *v == nil { 19027 sv = &types.ServerSideEncryptionRule{} 19028 } else { 19029 sv = *v 19030 } 19031 19032 for { 19033 t, done, err := decoder.Token() 19034 if err != nil { 19035 return err 19036 } 19037 if done { 19038 break 19039 } 19040 originalDecoder := decoder 19041 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19042 switch { 19043 case strings.EqualFold("ApplyServerSideEncryptionByDefault", t.Name.Local): 19044 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19045 if err := awsRestxml_deserializeDocumentServerSideEncryptionByDefault(&sv.ApplyServerSideEncryptionByDefault, nodeDecoder); err != nil { 19046 return err 19047 } 19048 19049 case strings.EqualFold("BucketKeyEnabled", t.Name.Local): 19050 val, err := decoder.Value() 19051 if err != nil { 19052 return err 19053 } 19054 if val == nil { 19055 break 19056 } 19057 { 19058 xtv, err := strconv.ParseBool(string(val)) 19059 if err != nil { 19060 return fmt.Errorf("expected BucketKeyEnabled to be of type *bool, got %T instead", val) 19061 } 19062 sv.BucketKeyEnabled = xtv 19063 } 19064 19065 default: 19066 // Do nothing and ignore the unexpected tag element 19067 err = decoder.Decoder.Skip() 19068 if err != nil { 19069 return err 19070 } 19071 19072 } 19073 decoder = originalDecoder 19074 } 19075 *v = sv 19076 return nil 19077} 19078 19079func awsRestxml_deserializeDocumentServerSideEncryptionRules(v *[]types.ServerSideEncryptionRule, decoder smithyxml.NodeDecoder) error { 19080 if v == nil { 19081 return fmt.Errorf("unexpected nil of type %T", v) 19082 } 19083 var sv []types.ServerSideEncryptionRule 19084 if *v == nil { 19085 sv = make([]types.ServerSideEncryptionRule, 0) 19086 } else { 19087 sv = *v 19088 } 19089 19090 originalDecoder := decoder 19091 for { 19092 t, done, err := decoder.Token() 19093 if err != nil { 19094 return err 19095 } 19096 if done { 19097 break 19098 } 19099 switch { 19100 case strings.EqualFold("member", t.Name.Local): 19101 var col types.ServerSideEncryptionRule 19102 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19103 destAddr := &col 19104 if err := awsRestxml_deserializeDocumentServerSideEncryptionRule(&destAddr, nodeDecoder); err != nil { 19105 return err 19106 } 19107 col = *destAddr 19108 sv = append(sv, col) 19109 19110 default: 19111 err = decoder.Decoder.Skip() 19112 if err != nil { 19113 return err 19114 } 19115 19116 } 19117 decoder = originalDecoder 19118 } 19119 *v = sv 19120 return nil 19121} 19122 19123func awsRestxml_deserializeDocumentServerSideEncryptionRulesUnwrapped(v *[]types.ServerSideEncryptionRule, decoder smithyxml.NodeDecoder) error { 19124 var sv []types.ServerSideEncryptionRule 19125 if *v == nil { 19126 sv = make([]types.ServerSideEncryptionRule, 0) 19127 } else { 19128 sv = *v 19129 } 19130 19131 switch { 19132 default: 19133 var mv types.ServerSideEncryptionRule 19134 t := decoder.StartEl 19135 _ = t 19136 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19137 destAddr := &mv 19138 if err := awsRestxml_deserializeDocumentServerSideEncryptionRule(&destAddr, nodeDecoder); err != nil { 19139 return err 19140 } 19141 mv = *destAddr 19142 sv = append(sv, mv) 19143 } 19144 *v = sv 19145 return nil 19146} 19147func awsRestxml_deserializeDocumentSourceSelectionCriteria(v **types.SourceSelectionCriteria, decoder smithyxml.NodeDecoder) error { 19148 if v == nil { 19149 return fmt.Errorf("unexpected nil of type %T", v) 19150 } 19151 var sv *types.SourceSelectionCriteria 19152 if *v == nil { 19153 sv = &types.SourceSelectionCriteria{} 19154 } else { 19155 sv = *v 19156 } 19157 19158 for { 19159 t, done, err := decoder.Token() 19160 if err != nil { 19161 return err 19162 } 19163 if done { 19164 break 19165 } 19166 originalDecoder := decoder 19167 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19168 switch { 19169 case strings.EqualFold("ReplicaModifications", t.Name.Local): 19170 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19171 if err := awsRestxml_deserializeDocumentReplicaModifications(&sv.ReplicaModifications, nodeDecoder); err != nil { 19172 return err 19173 } 19174 19175 case strings.EqualFold("SseKmsEncryptedObjects", t.Name.Local): 19176 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19177 if err := awsRestxml_deserializeDocumentSseKmsEncryptedObjects(&sv.SseKmsEncryptedObjects, nodeDecoder); err != nil { 19178 return err 19179 } 19180 19181 default: 19182 // Do nothing and ignore the unexpected tag element 19183 err = decoder.Decoder.Skip() 19184 if err != nil { 19185 return err 19186 } 19187 19188 } 19189 decoder = originalDecoder 19190 } 19191 *v = sv 19192 return nil 19193} 19194 19195func awsRestxml_deserializeDocumentSSEKMS(v **types.SSEKMS, decoder smithyxml.NodeDecoder) error { 19196 if v == nil { 19197 return fmt.Errorf("unexpected nil of type %T", v) 19198 } 19199 var sv *types.SSEKMS 19200 if *v == nil { 19201 sv = &types.SSEKMS{} 19202 } else { 19203 sv = *v 19204 } 19205 19206 for { 19207 t, done, err := decoder.Token() 19208 if err != nil { 19209 return err 19210 } 19211 if done { 19212 break 19213 } 19214 originalDecoder := decoder 19215 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19216 switch { 19217 case strings.EqualFold("KeyId", t.Name.Local): 19218 val, err := decoder.Value() 19219 if err != nil { 19220 return err 19221 } 19222 if val == nil { 19223 break 19224 } 19225 { 19226 xtv := string(val) 19227 sv.KeyId = ptr.String(xtv) 19228 } 19229 19230 default: 19231 // Do nothing and ignore the unexpected tag element 19232 err = decoder.Decoder.Skip() 19233 if err != nil { 19234 return err 19235 } 19236 19237 } 19238 decoder = originalDecoder 19239 } 19240 *v = sv 19241 return nil 19242} 19243 19244func awsRestxml_deserializeDocumentSseKmsEncryptedObjects(v **types.SseKmsEncryptedObjects, decoder smithyxml.NodeDecoder) error { 19245 if v == nil { 19246 return fmt.Errorf("unexpected nil of type %T", v) 19247 } 19248 var sv *types.SseKmsEncryptedObjects 19249 if *v == nil { 19250 sv = &types.SseKmsEncryptedObjects{} 19251 } else { 19252 sv = *v 19253 } 19254 19255 for { 19256 t, done, err := decoder.Token() 19257 if err != nil { 19258 return err 19259 } 19260 if done { 19261 break 19262 } 19263 originalDecoder := decoder 19264 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19265 switch { 19266 case strings.EqualFold("Status", t.Name.Local): 19267 val, err := decoder.Value() 19268 if err != nil { 19269 return err 19270 } 19271 if val == nil { 19272 break 19273 } 19274 { 19275 xtv := string(val) 19276 sv.Status = types.SseKmsEncryptedObjectsStatus(xtv) 19277 } 19278 19279 default: 19280 // Do nothing and ignore the unexpected tag element 19281 err = decoder.Decoder.Skip() 19282 if err != nil { 19283 return err 19284 } 19285 19286 } 19287 decoder = originalDecoder 19288 } 19289 *v = sv 19290 return nil 19291} 19292 19293func awsRestxml_deserializeDocumentSSES3(v **types.SSES3, decoder smithyxml.NodeDecoder) error { 19294 if v == nil { 19295 return fmt.Errorf("unexpected nil of type %T", v) 19296 } 19297 var sv *types.SSES3 19298 if *v == nil { 19299 sv = &types.SSES3{} 19300 } else { 19301 sv = *v 19302 } 19303 19304 for { 19305 t, done, err := decoder.Token() 19306 if err != nil { 19307 return err 19308 } 19309 if done { 19310 break 19311 } 19312 originalDecoder := decoder 19313 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19314 switch { 19315 default: 19316 // Do nothing and ignore the unexpected tag element 19317 err = decoder.Decoder.Skip() 19318 if err != nil { 19319 return err 19320 } 19321 19322 } 19323 decoder = originalDecoder 19324 } 19325 *v = sv 19326 return nil 19327} 19328 19329func awsRestxml_deserializeDocumentStorageClassAnalysis(v **types.StorageClassAnalysis, decoder smithyxml.NodeDecoder) error { 19330 if v == nil { 19331 return fmt.Errorf("unexpected nil of type %T", v) 19332 } 19333 var sv *types.StorageClassAnalysis 19334 if *v == nil { 19335 sv = &types.StorageClassAnalysis{} 19336 } else { 19337 sv = *v 19338 } 19339 19340 for { 19341 t, done, err := decoder.Token() 19342 if err != nil { 19343 return err 19344 } 19345 if done { 19346 break 19347 } 19348 originalDecoder := decoder 19349 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19350 switch { 19351 case strings.EqualFold("DataExport", t.Name.Local): 19352 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19353 if err := awsRestxml_deserializeDocumentStorageClassAnalysisDataExport(&sv.DataExport, nodeDecoder); err != nil { 19354 return err 19355 } 19356 19357 default: 19358 // Do nothing and ignore the unexpected tag element 19359 err = decoder.Decoder.Skip() 19360 if err != nil { 19361 return err 19362 } 19363 19364 } 19365 decoder = originalDecoder 19366 } 19367 *v = sv 19368 return nil 19369} 19370 19371func awsRestxml_deserializeDocumentStorageClassAnalysisDataExport(v **types.StorageClassAnalysisDataExport, decoder smithyxml.NodeDecoder) error { 19372 if v == nil { 19373 return fmt.Errorf("unexpected nil of type %T", v) 19374 } 19375 var sv *types.StorageClassAnalysisDataExport 19376 if *v == nil { 19377 sv = &types.StorageClassAnalysisDataExport{} 19378 } else { 19379 sv = *v 19380 } 19381 19382 for { 19383 t, done, err := decoder.Token() 19384 if err != nil { 19385 return err 19386 } 19387 if done { 19388 break 19389 } 19390 originalDecoder := decoder 19391 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19392 switch { 19393 case strings.EqualFold("Destination", t.Name.Local): 19394 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19395 if err := awsRestxml_deserializeDocumentAnalyticsExportDestination(&sv.Destination, nodeDecoder); err != nil { 19396 return err 19397 } 19398 19399 case strings.EqualFold("OutputSchemaVersion", t.Name.Local): 19400 val, err := decoder.Value() 19401 if err != nil { 19402 return err 19403 } 19404 if val == nil { 19405 break 19406 } 19407 { 19408 xtv := string(val) 19409 sv.OutputSchemaVersion = types.StorageClassAnalysisSchemaVersion(xtv) 19410 } 19411 19412 default: 19413 // Do nothing and ignore the unexpected tag element 19414 err = decoder.Decoder.Skip() 19415 if err != nil { 19416 return err 19417 } 19418 19419 } 19420 decoder = originalDecoder 19421 } 19422 *v = sv 19423 return nil 19424} 19425 19426func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { 19427 if v == nil { 19428 return fmt.Errorf("unexpected nil of type %T", v) 19429 } 19430 var sv *types.Tag 19431 if *v == nil { 19432 sv = &types.Tag{} 19433 } else { 19434 sv = *v 19435 } 19436 19437 for { 19438 t, done, err := decoder.Token() 19439 if err != nil { 19440 return err 19441 } 19442 if done { 19443 break 19444 } 19445 originalDecoder := decoder 19446 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19447 switch { 19448 case strings.EqualFold("Key", t.Name.Local): 19449 val, err := decoder.Value() 19450 if err != nil { 19451 return err 19452 } 19453 if val == nil { 19454 break 19455 } 19456 { 19457 xtv := string(val) 19458 sv.Key = ptr.String(xtv) 19459 } 19460 19461 case strings.EqualFold("Value", t.Name.Local): 19462 val, err := decoder.Value() 19463 if err != nil { 19464 return err 19465 } 19466 if val == nil { 19467 break 19468 } 19469 { 19470 xtv := string(val) 19471 sv.Value = ptr.String(xtv) 19472 } 19473 19474 default: 19475 // Do nothing and ignore the unexpected tag element 19476 err = decoder.Decoder.Skip() 19477 if err != nil { 19478 return err 19479 } 19480 19481 } 19482 decoder = originalDecoder 19483 } 19484 *v = sv 19485 return nil 19486} 19487 19488func awsRestxml_deserializeDocumentTagSet(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 19489 if v == nil { 19490 return fmt.Errorf("unexpected nil of type %T", v) 19491 } 19492 var sv []types.Tag 19493 if *v == nil { 19494 sv = make([]types.Tag, 0) 19495 } else { 19496 sv = *v 19497 } 19498 19499 originalDecoder := decoder 19500 for { 19501 t, done, err := decoder.Token() 19502 if err != nil { 19503 return err 19504 } 19505 if done { 19506 break 19507 } 19508 switch { 19509 case strings.EqualFold("Tag", t.Name.Local): 19510 var col types.Tag 19511 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19512 destAddr := &col 19513 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 19514 return err 19515 } 19516 col = *destAddr 19517 sv = append(sv, col) 19518 19519 default: 19520 err = decoder.Decoder.Skip() 19521 if err != nil { 19522 return err 19523 } 19524 19525 } 19526 decoder = originalDecoder 19527 } 19528 *v = sv 19529 return nil 19530} 19531 19532func awsRestxml_deserializeDocumentTagSetUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 19533 var sv []types.Tag 19534 if *v == nil { 19535 sv = make([]types.Tag, 0) 19536 } else { 19537 sv = *v 19538 } 19539 19540 switch { 19541 default: 19542 var mv types.Tag 19543 t := decoder.StartEl 19544 _ = t 19545 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19546 destAddr := &mv 19547 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 19548 return err 19549 } 19550 mv = *destAddr 19551 sv = append(sv, mv) 19552 } 19553 *v = sv 19554 return nil 19555} 19556func awsRestxml_deserializeDocumentTargetGrant(v **types.TargetGrant, decoder smithyxml.NodeDecoder) error { 19557 if v == nil { 19558 return fmt.Errorf("unexpected nil of type %T", v) 19559 } 19560 var sv *types.TargetGrant 19561 if *v == nil { 19562 sv = &types.TargetGrant{} 19563 } else { 19564 sv = *v 19565 } 19566 19567 for { 19568 t, done, err := decoder.Token() 19569 if err != nil { 19570 return err 19571 } 19572 if done { 19573 break 19574 } 19575 originalDecoder := decoder 19576 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19577 switch { 19578 case strings.EqualFold("Grantee", t.Name.Local): 19579 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19580 if err := awsRestxml_deserializeDocumentGrantee(&sv.Grantee, nodeDecoder); err != nil { 19581 return err 19582 } 19583 19584 case strings.EqualFold("Permission", t.Name.Local): 19585 val, err := decoder.Value() 19586 if err != nil { 19587 return err 19588 } 19589 if val == nil { 19590 break 19591 } 19592 { 19593 xtv := string(val) 19594 sv.Permission = types.BucketLogsPermission(xtv) 19595 } 19596 19597 default: 19598 // Do nothing and ignore the unexpected tag element 19599 err = decoder.Decoder.Skip() 19600 if err != nil { 19601 return err 19602 } 19603 19604 } 19605 decoder = originalDecoder 19606 } 19607 *v = sv 19608 return nil 19609} 19610 19611func awsRestxml_deserializeDocumentTargetGrants(v *[]types.TargetGrant, decoder smithyxml.NodeDecoder) error { 19612 if v == nil { 19613 return fmt.Errorf("unexpected nil of type %T", v) 19614 } 19615 var sv []types.TargetGrant 19616 if *v == nil { 19617 sv = make([]types.TargetGrant, 0) 19618 } else { 19619 sv = *v 19620 } 19621 19622 originalDecoder := decoder 19623 for { 19624 t, done, err := decoder.Token() 19625 if err != nil { 19626 return err 19627 } 19628 if done { 19629 break 19630 } 19631 switch { 19632 case strings.EqualFold("Grant", t.Name.Local): 19633 var col types.TargetGrant 19634 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19635 destAddr := &col 19636 if err := awsRestxml_deserializeDocumentTargetGrant(&destAddr, nodeDecoder); err != nil { 19637 return err 19638 } 19639 col = *destAddr 19640 sv = append(sv, col) 19641 19642 default: 19643 err = decoder.Decoder.Skip() 19644 if err != nil { 19645 return err 19646 } 19647 19648 } 19649 decoder = originalDecoder 19650 } 19651 *v = sv 19652 return nil 19653} 19654 19655func awsRestxml_deserializeDocumentTargetGrantsUnwrapped(v *[]types.TargetGrant, decoder smithyxml.NodeDecoder) error { 19656 var sv []types.TargetGrant 19657 if *v == nil { 19658 sv = make([]types.TargetGrant, 0) 19659 } else { 19660 sv = *v 19661 } 19662 19663 switch { 19664 default: 19665 var mv types.TargetGrant 19666 t := decoder.StartEl 19667 _ = t 19668 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19669 destAddr := &mv 19670 if err := awsRestxml_deserializeDocumentTargetGrant(&destAddr, nodeDecoder); err != nil { 19671 return err 19672 } 19673 mv = *destAddr 19674 sv = append(sv, mv) 19675 } 19676 *v = sv 19677 return nil 19678} 19679func awsRestxml_deserializeDocumentTiering(v **types.Tiering, decoder smithyxml.NodeDecoder) error { 19680 if v == nil { 19681 return fmt.Errorf("unexpected nil of type %T", v) 19682 } 19683 var sv *types.Tiering 19684 if *v == nil { 19685 sv = &types.Tiering{} 19686 } else { 19687 sv = *v 19688 } 19689 19690 for { 19691 t, done, err := decoder.Token() 19692 if err != nil { 19693 return err 19694 } 19695 if done { 19696 break 19697 } 19698 originalDecoder := decoder 19699 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19700 switch { 19701 case strings.EqualFold("AccessTier", t.Name.Local): 19702 val, err := decoder.Value() 19703 if err != nil { 19704 return err 19705 } 19706 if val == nil { 19707 break 19708 } 19709 { 19710 xtv := string(val) 19711 sv.AccessTier = types.IntelligentTieringAccessTier(xtv) 19712 } 19713 19714 case strings.EqualFold("Days", t.Name.Local): 19715 val, err := decoder.Value() 19716 if err != nil { 19717 return err 19718 } 19719 if val == nil { 19720 break 19721 } 19722 { 19723 xtv := string(val) 19724 i64, err := strconv.ParseInt(xtv, 10, 64) 19725 if err != nil { 19726 return err 19727 } 19728 sv.Days = int32(i64) 19729 } 19730 19731 default: 19732 // Do nothing and ignore the unexpected tag element 19733 err = decoder.Decoder.Skip() 19734 if err != nil { 19735 return err 19736 } 19737 19738 } 19739 decoder = originalDecoder 19740 } 19741 *v = sv 19742 return nil 19743} 19744 19745func awsRestxml_deserializeDocumentTieringList(v *[]types.Tiering, decoder smithyxml.NodeDecoder) error { 19746 if v == nil { 19747 return fmt.Errorf("unexpected nil of type %T", v) 19748 } 19749 var sv []types.Tiering 19750 if *v == nil { 19751 sv = make([]types.Tiering, 0) 19752 } else { 19753 sv = *v 19754 } 19755 19756 originalDecoder := decoder 19757 for { 19758 t, done, err := decoder.Token() 19759 if err != nil { 19760 return err 19761 } 19762 if done { 19763 break 19764 } 19765 switch { 19766 case strings.EqualFold("member", t.Name.Local): 19767 var col types.Tiering 19768 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19769 destAddr := &col 19770 if err := awsRestxml_deserializeDocumentTiering(&destAddr, nodeDecoder); err != nil { 19771 return err 19772 } 19773 col = *destAddr 19774 sv = append(sv, col) 19775 19776 default: 19777 err = decoder.Decoder.Skip() 19778 if err != nil { 19779 return err 19780 } 19781 19782 } 19783 decoder = originalDecoder 19784 } 19785 *v = sv 19786 return nil 19787} 19788 19789func awsRestxml_deserializeDocumentTieringListUnwrapped(v *[]types.Tiering, decoder smithyxml.NodeDecoder) error { 19790 var sv []types.Tiering 19791 if *v == nil { 19792 sv = make([]types.Tiering, 0) 19793 } else { 19794 sv = *v 19795 } 19796 19797 switch { 19798 default: 19799 var mv types.Tiering 19800 t := decoder.StartEl 19801 _ = t 19802 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19803 destAddr := &mv 19804 if err := awsRestxml_deserializeDocumentTiering(&destAddr, nodeDecoder); err != nil { 19805 return err 19806 } 19807 mv = *destAddr 19808 sv = append(sv, mv) 19809 } 19810 *v = sv 19811 return nil 19812} 19813func awsRestxml_deserializeDocumentTopicConfiguration(v **types.TopicConfiguration, decoder smithyxml.NodeDecoder) error { 19814 if v == nil { 19815 return fmt.Errorf("unexpected nil of type %T", v) 19816 } 19817 var sv *types.TopicConfiguration 19818 if *v == nil { 19819 sv = &types.TopicConfiguration{} 19820 } else { 19821 sv = *v 19822 } 19823 19824 for { 19825 t, done, err := decoder.Token() 19826 if err != nil { 19827 return err 19828 } 19829 if done { 19830 break 19831 } 19832 originalDecoder := decoder 19833 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19834 switch { 19835 case strings.EqualFold("Event", t.Name.Local): 19836 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19837 if err := awsRestxml_deserializeDocumentEventListUnwrapped(&sv.Events, nodeDecoder); err != nil { 19838 return err 19839 } 19840 19841 case strings.EqualFold("Filter", t.Name.Local): 19842 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19843 if err := awsRestxml_deserializeDocumentNotificationConfigurationFilter(&sv.Filter, nodeDecoder); err != nil { 19844 return err 19845 } 19846 19847 case strings.EqualFold("Id", t.Name.Local): 19848 val, err := decoder.Value() 19849 if err != nil { 19850 return err 19851 } 19852 if val == nil { 19853 break 19854 } 19855 { 19856 xtv := string(val) 19857 sv.Id = ptr.String(xtv) 19858 } 19859 19860 case strings.EqualFold("Topic", t.Name.Local): 19861 val, err := decoder.Value() 19862 if err != nil { 19863 return err 19864 } 19865 if val == nil { 19866 break 19867 } 19868 { 19869 xtv := string(val) 19870 sv.TopicArn = ptr.String(xtv) 19871 } 19872 19873 default: 19874 // Do nothing and ignore the unexpected tag element 19875 err = decoder.Decoder.Skip() 19876 if err != nil { 19877 return err 19878 } 19879 19880 } 19881 decoder = originalDecoder 19882 } 19883 *v = sv 19884 return nil 19885} 19886 19887func awsRestxml_deserializeDocumentTopicConfigurationList(v *[]types.TopicConfiguration, decoder smithyxml.NodeDecoder) error { 19888 if v == nil { 19889 return fmt.Errorf("unexpected nil of type %T", v) 19890 } 19891 var sv []types.TopicConfiguration 19892 if *v == nil { 19893 sv = make([]types.TopicConfiguration, 0) 19894 } else { 19895 sv = *v 19896 } 19897 19898 originalDecoder := decoder 19899 for { 19900 t, done, err := decoder.Token() 19901 if err != nil { 19902 return err 19903 } 19904 if done { 19905 break 19906 } 19907 switch { 19908 case strings.EqualFold("member", t.Name.Local): 19909 var col types.TopicConfiguration 19910 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19911 destAddr := &col 19912 if err := awsRestxml_deserializeDocumentTopicConfiguration(&destAddr, nodeDecoder); err != nil { 19913 return err 19914 } 19915 col = *destAddr 19916 sv = append(sv, col) 19917 19918 default: 19919 err = decoder.Decoder.Skip() 19920 if err != nil { 19921 return err 19922 } 19923 19924 } 19925 decoder = originalDecoder 19926 } 19927 *v = sv 19928 return nil 19929} 19930 19931func awsRestxml_deserializeDocumentTopicConfigurationListUnwrapped(v *[]types.TopicConfiguration, decoder smithyxml.NodeDecoder) error { 19932 var sv []types.TopicConfiguration 19933 if *v == nil { 19934 sv = make([]types.TopicConfiguration, 0) 19935 } else { 19936 sv = *v 19937 } 19938 19939 switch { 19940 default: 19941 var mv types.TopicConfiguration 19942 t := decoder.StartEl 19943 _ = t 19944 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19945 destAddr := &mv 19946 if err := awsRestxml_deserializeDocumentTopicConfiguration(&destAddr, nodeDecoder); err != nil { 19947 return err 19948 } 19949 mv = *destAddr 19950 sv = append(sv, mv) 19951 } 19952 *v = sv 19953 return nil 19954} 19955func awsRestxml_deserializeDocumentTransition(v **types.Transition, decoder smithyxml.NodeDecoder) error { 19956 if v == nil { 19957 return fmt.Errorf("unexpected nil of type %T", v) 19958 } 19959 var sv *types.Transition 19960 if *v == nil { 19961 sv = &types.Transition{} 19962 } else { 19963 sv = *v 19964 } 19965 19966 for { 19967 t, done, err := decoder.Token() 19968 if err != nil { 19969 return err 19970 } 19971 if done { 19972 break 19973 } 19974 originalDecoder := decoder 19975 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19976 switch { 19977 case strings.EqualFold("Date", t.Name.Local): 19978 val, err := decoder.Value() 19979 if err != nil { 19980 return err 19981 } 19982 if val == nil { 19983 break 19984 } 19985 { 19986 xtv := string(val) 19987 t, err := smithytime.ParseDateTime(xtv) 19988 if err != nil { 19989 return err 19990 } 19991 sv.Date = ptr.Time(t) 19992 } 19993 19994 case strings.EqualFold("Days", t.Name.Local): 19995 val, err := decoder.Value() 19996 if err != nil { 19997 return err 19998 } 19999 if val == nil { 20000 break 20001 } 20002 { 20003 xtv := string(val) 20004 i64, err := strconv.ParseInt(xtv, 10, 64) 20005 if err != nil { 20006 return err 20007 } 20008 sv.Days = int32(i64) 20009 } 20010 20011 case strings.EqualFold("StorageClass", t.Name.Local): 20012 val, err := decoder.Value() 20013 if err != nil { 20014 return err 20015 } 20016 if val == nil { 20017 break 20018 } 20019 { 20020 xtv := string(val) 20021 sv.StorageClass = types.TransitionStorageClass(xtv) 20022 } 20023 20024 default: 20025 // Do nothing and ignore the unexpected tag element 20026 err = decoder.Decoder.Skip() 20027 if err != nil { 20028 return err 20029 } 20030 20031 } 20032 decoder = originalDecoder 20033 } 20034 *v = sv 20035 return nil 20036} 20037 20038func awsRestxml_deserializeDocumentTransitionList(v *[]types.Transition, decoder smithyxml.NodeDecoder) error { 20039 if v == nil { 20040 return fmt.Errorf("unexpected nil of type %T", v) 20041 } 20042 var sv []types.Transition 20043 if *v == nil { 20044 sv = make([]types.Transition, 0) 20045 } else { 20046 sv = *v 20047 } 20048 20049 originalDecoder := decoder 20050 for { 20051 t, done, err := decoder.Token() 20052 if err != nil { 20053 return err 20054 } 20055 if done { 20056 break 20057 } 20058 switch { 20059 case strings.EqualFold("member", t.Name.Local): 20060 var col types.Transition 20061 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20062 destAddr := &col 20063 if err := awsRestxml_deserializeDocumentTransition(&destAddr, nodeDecoder); err != nil { 20064 return err 20065 } 20066 col = *destAddr 20067 sv = append(sv, col) 20068 20069 default: 20070 err = decoder.Decoder.Skip() 20071 if err != nil { 20072 return err 20073 } 20074 20075 } 20076 decoder = originalDecoder 20077 } 20078 *v = sv 20079 return nil 20080} 20081 20082func awsRestxml_deserializeDocumentTransitionListUnwrapped(v *[]types.Transition, decoder smithyxml.NodeDecoder) error { 20083 var sv []types.Transition 20084 if *v == nil { 20085 sv = make([]types.Transition, 0) 20086 } else { 20087 sv = *v 20088 } 20089 20090 switch { 20091 default: 20092 var mv types.Transition 20093 t := decoder.StartEl 20094 _ = t 20095 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20096 destAddr := &mv 20097 if err := awsRestxml_deserializeDocumentTransition(&destAddr, nodeDecoder); err != nil { 20098 return err 20099 } 20100 mv = *destAddr 20101 sv = append(sv, mv) 20102 } 20103 *v = sv 20104 return nil 20105} 20106