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 err = awsRestxml_deserializeOpDocumentGetBucketPolicyOutput(output, response.Body) 4151 if err != nil { 4152 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 4153 } 4154 4155 return out, metadata, err 4156} 4157 4158func awsRestxml_deserializeOpErrorGetBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4159 var errorBuffer bytes.Buffer 4160 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4161 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4162 } 4163 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4164 4165 errorCode := "UnknownError" 4166 errorMessage := errorCode 4167 4168 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4169 UseStatusCode: true, StatusCode: response.StatusCode, 4170 }) 4171 if err != nil { 4172 return err 4173 } 4174 if hostID := errorComponents.HostID; len(hostID) != 0 { 4175 s3shared.SetHostIDMetadata(metadata, hostID) 4176 } 4177 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4178 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4179 } 4180 if len(errorComponents.Code) != 0 { 4181 errorCode = errorComponents.Code 4182 } 4183 if len(errorComponents.Message) != 0 { 4184 errorMessage = errorComponents.Message 4185 } 4186 errorBody.Seek(0, io.SeekStart) 4187 switch { 4188 default: 4189 genericError := &smithy.GenericAPIError{ 4190 Code: errorCode, 4191 Message: errorMessage, 4192 } 4193 return genericError 4194 4195 } 4196} 4197 4198func awsRestxml_deserializeOpDocumentGetBucketPolicyOutput(v *GetBucketPolicyOutput, body io.ReadCloser) error { 4199 if v == nil { 4200 return fmt.Errorf("unsupported deserialization of nil %T", v) 4201 } 4202 bs, err := ioutil.ReadAll(body) 4203 if err != nil { 4204 return err 4205 } 4206 if len(bs) > 0 { 4207 v.Policy = ptr.String(string(bs)) 4208 } 4209 return nil 4210} 4211 4212type awsRestxml_deserializeOpGetBucketPolicyStatus struct { 4213} 4214 4215func (*awsRestxml_deserializeOpGetBucketPolicyStatus) ID() string { 4216 return "OperationDeserializer" 4217} 4218 4219func (m *awsRestxml_deserializeOpGetBucketPolicyStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4220 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4221) { 4222 out, metadata, err = next.HandleDeserialize(ctx, in) 4223 if err != nil { 4224 return out, metadata, err 4225 } 4226 4227 response, ok := out.RawResponse.(*smithyhttp.Response) 4228 if !ok { 4229 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4230 } 4231 4232 if response.StatusCode < 200 || response.StatusCode >= 300 { 4233 return out, metadata, awsRestxml_deserializeOpErrorGetBucketPolicyStatus(response, &metadata) 4234 } 4235 output := &GetBucketPolicyStatusOutput{} 4236 out.Result = output 4237 4238 var buff [1024]byte 4239 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4240 body := io.TeeReader(response.Body, ringBuffer) 4241 rootDecoder := xml.NewDecoder(body) 4242 t, err := smithyxml.FetchRootElement(rootDecoder) 4243 if err == io.EOF { 4244 return out, metadata, nil 4245 } 4246 if err != nil { 4247 var snapshot bytes.Buffer 4248 io.Copy(&snapshot, ringBuffer) 4249 return out, metadata, &smithy.DeserializationError{ 4250 Err: fmt.Errorf("failed to decode response body, %w", err), 4251 Snapshot: snapshot.Bytes(), 4252 } 4253 } 4254 4255 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4256 err = awsRestxml_deserializeDocumentPolicyStatus(&output.PolicyStatus, decoder) 4257 if err != nil { 4258 var snapshot bytes.Buffer 4259 io.Copy(&snapshot, ringBuffer) 4260 return out, metadata, &smithy.DeserializationError{ 4261 Err: fmt.Errorf("failed to decode response body, %w", err), 4262 Snapshot: snapshot.Bytes(), 4263 } 4264 } 4265 4266 return out, metadata, err 4267} 4268 4269func awsRestxml_deserializeOpErrorGetBucketPolicyStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4270 var errorBuffer bytes.Buffer 4271 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4272 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4273 } 4274 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4275 4276 errorCode := "UnknownError" 4277 errorMessage := errorCode 4278 4279 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4280 UseStatusCode: true, StatusCode: response.StatusCode, 4281 }) 4282 if err != nil { 4283 return err 4284 } 4285 if hostID := errorComponents.HostID; len(hostID) != 0 { 4286 s3shared.SetHostIDMetadata(metadata, hostID) 4287 } 4288 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4289 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4290 } 4291 if len(errorComponents.Code) != 0 { 4292 errorCode = errorComponents.Code 4293 } 4294 if len(errorComponents.Message) != 0 { 4295 errorMessage = errorComponents.Message 4296 } 4297 errorBody.Seek(0, io.SeekStart) 4298 switch { 4299 default: 4300 genericError := &smithy.GenericAPIError{ 4301 Code: errorCode, 4302 Message: errorMessage, 4303 } 4304 return genericError 4305 4306 } 4307} 4308 4309func awsRestxml_deserializeOpDocumentGetBucketPolicyStatusOutput(v **GetBucketPolicyStatusOutput, decoder smithyxml.NodeDecoder) error { 4310 if v == nil { 4311 return fmt.Errorf("unexpected nil of type %T", v) 4312 } 4313 var sv *GetBucketPolicyStatusOutput 4314 if *v == nil { 4315 sv = &GetBucketPolicyStatusOutput{} 4316 } else { 4317 sv = *v 4318 } 4319 4320 for { 4321 t, done, err := decoder.Token() 4322 if err != nil { 4323 return err 4324 } 4325 if done { 4326 break 4327 } 4328 originalDecoder := decoder 4329 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4330 switch { 4331 case strings.EqualFold("PolicyStatus", t.Name.Local): 4332 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4333 if err := awsRestxml_deserializeDocumentPolicyStatus(&sv.PolicyStatus, nodeDecoder); err != nil { 4334 return err 4335 } 4336 4337 default: 4338 // Do nothing and ignore the unexpected tag element 4339 err = decoder.Decoder.Skip() 4340 if err != nil { 4341 return err 4342 } 4343 4344 } 4345 decoder = originalDecoder 4346 } 4347 *v = sv 4348 return nil 4349} 4350 4351type awsRestxml_deserializeOpGetBucketReplication struct { 4352} 4353 4354func (*awsRestxml_deserializeOpGetBucketReplication) ID() string { 4355 return "OperationDeserializer" 4356} 4357 4358func (m *awsRestxml_deserializeOpGetBucketReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4359 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4360) { 4361 out, metadata, err = next.HandleDeserialize(ctx, in) 4362 if err != nil { 4363 return out, metadata, err 4364 } 4365 4366 response, ok := out.RawResponse.(*smithyhttp.Response) 4367 if !ok { 4368 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4369 } 4370 4371 if response.StatusCode < 200 || response.StatusCode >= 300 { 4372 return out, metadata, awsRestxml_deserializeOpErrorGetBucketReplication(response, &metadata) 4373 } 4374 output := &GetBucketReplicationOutput{} 4375 out.Result = output 4376 4377 var buff [1024]byte 4378 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4379 body := io.TeeReader(response.Body, ringBuffer) 4380 rootDecoder := xml.NewDecoder(body) 4381 t, err := smithyxml.FetchRootElement(rootDecoder) 4382 if err == io.EOF { 4383 return out, metadata, nil 4384 } 4385 if err != nil { 4386 var snapshot bytes.Buffer 4387 io.Copy(&snapshot, ringBuffer) 4388 return out, metadata, &smithy.DeserializationError{ 4389 Err: fmt.Errorf("failed to decode response body, %w", err), 4390 Snapshot: snapshot.Bytes(), 4391 } 4392 } 4393 4394 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4395 err = awsRestxml_deserializeDocumentReplicationConfiguration(&output.ReplicationConfiguration, decoder) 4396 if err != nil { 4397 var snapshot bytes.Buffer 4398 io.Copy(&snapshot, ringBuffer) 4399 return out, metadata, &smithy.DeserializationError{ 4400 Err: fmt.Errorf("failed to decode response body, %w", err), 4401 Snapshot: snapshot.Bytes(), 4402 } 4403 } 4404 4405 return out, metadata, err 4406} 4407 4408func awsRestxml_deserializeOpErrorGetBucketReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4409 var errorBuffer bytes.Buffer 4410 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4411 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4412 } 4413 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4414 4415 errorCode := "UnknownError" 4416 errorMessage := errorCode 4417 4418 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4419 UseStatusCode: true, StatusCode: response.StatusCode, 4420 }) 4421 if err != nil { 4422 return err 4423 } 4424 if hostID := errorComponents.HostID; len(hostID) != 0 { 4425 s3shared.SetHostIDMetadata(metadata, hostID) 4426 } 4427 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4428 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4429 } 4430 if len(errorComponents.Code) != 0 { 4431 errorCode = errorComponents.Code 4432 } 4433 if len(errorComponents.Message) != 0 { 4434 errorMessage = errorComponents.Message 4435 } 4436 errorBody.Seek(0, io.SeekStart) 4437 switch { 4438 default: 4439 genericError := &smithy.GenericAPIError{ 4440 Code: errorCode, 4441 Message: errorMessage, 4442 } 4443 return genericError 4444 4445 } 4446} 4447 4448func awsRestxml_deserializeOpDocumentGetBucketReplicationOutput(v **GetBucketReplicationOutput, decoder smithyxml.NodeDecoder) error { 4449 if v == nil { 4450 return fmt.Errorf("unexpected nil of type %T", v) 4451 } 4452 var sv *GetBucketReplicationOutput 4453 if *v == nil { 4454 sv = &GetBucketReplicationOutput{} 4455 } else { 4456 sv = *v 4457 } 4458 4459 for { 4460 t, done, err := decoder.Token() 4461 if err != nil { 4462 return err 4463 } 4464 if done { 4465 break 4466 } 4467 originalDecoder := decoder 4468 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4469 switch { 4470 case strings.EqualFold("ReplicationConfiguration", t.Name.Local): 4471 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4472 if err := awsRestxml_deserializeDocumentReplicationConfiguration(&sv.ReplicationConfiguration, nodeDecoder); err != nil { 4473 return err 4474 } 4475 4476 default: 4477 // Do nothing and ignore the unexpected tag element 4478 err = decoder.Decoder.Skip() 4479 if err != nil { 4480 return err 4481 } 4482 4483 } 4484 decoder = originalDecoder 4485 } 4486 *v = sv 4487 return nil 4488} 4489 4490type awsRestxml_deserializeOpGetBucketRequestPayment struct { 4491} 4492 4493func (*awsRestxml_deserializeOpGetBucketRequestPayment) ID() string { 4494 return "OperationDeserializer" 4495} 4496 4497func (m *awsRestxml_deserializeOpGetBucketRequestPayment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4498 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4499) { 4500 out, metadata, err = next.HandleDeserialize(ctx, in) 4501 if err != nil { 4502 return out, metadata, err 4503 } 4504 4505 response, ok := out.RawResponse.(*smithyhttp.Response) 4506 if !ok { 4507 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4508 } 4509 4510 if response.StatusCode < 200 || response.StatusCode >= 300 { 4511 return out, metadata, awsRestxml_deserializeOpErrorGetBucketRequestPayment(response, &metadata) 4512 } 4513 output := &GetBucketRequestPaymentOutput{} 4514 out.Result = output 4515 4516 var buff [1024]byte 4517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4518 body := io.TeeReader(response.Body, ringBuffer) 4519 rootDecoder := xml.NewDecoder(body) 4520 t, err := smithyxml.FetchRootElement(rootDecoder) 4521 if err == io.EOF { 4522 return out, metadata, nil 4523 } 4524 if err != nil { 4525 var snapshot bytes.Buffer 4526 io.Copy(&snapshot, ringBuffer) 4527 return out, metadata, &smithy.DeserializationError{ 4528 Err: fmt.Errorf("failed to decode response body, %w", err), 4529 Snapshot: snapshot.Bytes(), 4530 } 4531 } 4532 4533 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4534 err = awsRestxml_deserializeOpDocumentGetBucketRequestPaymentOutput(&output, decoder) 4535 if err != nil { 4536 var snapshot bytes.Buffer 4537 io.Copy(&snapshot, ringBuffer) 4538 return out, metadata, &smithy.DeserializationError{ 4539 Err: fmt.Errorf("failed to decode response body, %w", err), 4540 Snapshot: snapshot.Bytes(), 4541 } 4542 } 4543 4544 return out, metadata, err 4545} 4546 4547func awsRestxml_deserializeOpErrorGetBucketRequestPayment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4548 var errorBuffer bytes.Buffer 4549 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4550 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4551 } 4552 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4553 4554 errorCode := "UnknownError" 4555 errorMessage := errorCode 4556 4557 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4558 UseStatusCode: true, StatusCode: response.StatusCode, 4559 }) 4560 if err != nil { 4561 return err 4562 } 4563 if hostID := errorComponents.HostID; len(hostID) != 0 { 4564 s3shared.SetHostIDMetadata(metadata, hostID) 4565 } 4566 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4567 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4568 } 4569 if len(errorComponents.Code) != 0 { 4570 errorCode = errorComponents.Code 4571 } 4572 if len(errorComponents.Message) != 0 { 4573 errorMessage = errorComponents.Message 4574 } 4575 errorBody.Seek(0, io.SeekStart) 4576 switch { 4577 default: 4578 genericError := &smithy.GenericAPIError{ 4579 Code: errorCode, 4580 Message: errorMessage, 4581 } 4582 return genericError 4583 4584 } 4585} 4586 4587func awsRestxml_deserializeOpDocumentGetBucketRequestPaymentOutput(v **GetBucketRequestPaymentOutput, decoder smithyxml.NodeDecoder) error { 4588 if v == nil { 4589 return fmt.Errorf("unexpected nil of type %T", v) 4590 } 4591 var sv *GetBucketRequestPaymentOutput 4592 if *v == nil { 4593 sv = &GetBucketRequestPaymentOutput{} 4594 } else { 4595 sv = *v 4596 } 4597 4598 for { 4599 t, done, err := decoder.Token() 4600 if err != nil { 4601 return err 4602 } 4603 if done { 4604 break 4605 } 4606 originalDecoder := decoder 4607 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4608 switch { 4609 case strings.EqualFold("Payer", t.Name.Local): 4610 val, err := decoder.Value() 4611 if err != nil { 4612 return err 4613 } 4614 if val == nil { 4615 break 4616 } 4617 { 4618 xtv := string(val) 4619 sv.Payer = types.Payer(xtv) 4620 } 4621 4622 default: 4623 // Do nothing and ignore the unexpected tag element 4624 err = decoder.Decoder.Skip() 4625 if err != nil { 4626 return err 4627 } 4628 4629 } 4630 decoder = originalDecoder 4631 } 4632 *v = sv 4633 return nil 4634} 4635 4636type awsRestxml_deserializeOpGetBucketTagging struct { 4637} 4638 4639func (*awsRestxml_deserializeOpGetBucketTagging) ID() string { 4640 return "OperationDeserializer" 4641} 4642 4643func (m *awsRestxml_deserializeOpGetBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4644 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4645) { 4646 out, metadata, err = next.HandleDeserialize(ctx, in) 4647 if err != nil { 4648 return out, metadata, err 4649 } 4650 4651 response, ok := out.RawResponse.(*smithyhttp.Response) 4652 if !ok { 4653 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4654 } 4655 4656 if response.StatusCode < 200 || response.StatusCode >= 300 { 4657 return out, metadata, awsRestxml_deserializeOpErrorGetBucketTagging(response, &metadata) 4658 } 4659 output := &GetBucketTaggingOutput{} 4660 out.Result = output 4661 4662 var buff [1024]byte 4663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4664 body := io.TeeReader(response.Body, ringBuffer) 4665 rootDecoder := xml.NewDecoder(body) 4666 t, err := smithyxml.FetchRootElement(rootDecoder) 4667 if err == io.EOF { 4668 return out, metadata, nil 4669 } 4670 if err != nil { 4671 var snapshot bytes.Buffer 4672 io.Copy(&snapshot, ringBuffer) 4673 return out, metadata, &smithy.DeserializationError{ 4674 Err: fmt.Errorf("failed to decode response body, %w", err), 4675 Snapshot: snapshot.Bytes(), 4676 } 4677 } 4678 4679 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4680 err = awsRestxml_deserializeOpDocumentGetBucketTaggingOutput(&output, decoder) 4681 if err != nil { 4682 var snapshot bytes.Buffer 4683 io.Copy(&snapshot, ringBuffer) 4684 return out, metadata, &smithy.DeserializationError{ 4685 Err: fmt.Errorf("failed to decode response body, %w", err), 4686 Snapshot: snapshot.Bytes(), 4687 } 4688 } 4689 4690 return out, metadata, err 4691} 4692 4693func awsRestxml_deserializeOpErrorGetBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4694 var errorBuffer bytes.Buffer 4695 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4696 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4697 } 4698 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4699 4700 errorCode := "UnknownError" 4701 errorMessage := errorCode 4702 4703 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4704 UseStatusCode: true, StatusCode: response.StatusCode, 4705 }) 4706 if err != nil { 4707 return err 4708 } 4709 if hostID := errorComponents.HostID; len(hostID) != 0 { 4710 s3shared.SetHostIDMetadata(metadata, hostID) 4711 } 4712 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4713 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4714 } 4715 if len(errorComponents.Code) != 0 { 4716 errorCode = errorComponents.Code 4717 } 4718 if len(errorComponents.Message) != 0 { 4719 errorMessage = errorComponents.Message 4720 } 4721 errorBody.Seek(0, io.SeekStart) 4722 switch { 4723 default: 4724 genericError := &smithy.GenericAPIError{ 4725 Code: errorCode, 4726 Message: errorMessage, 4727 } 4728 return genericError 4729 4730 } 4731} 4732 4733func awsRestxml_deserializeOpDocumentGetBucketTaggingOutput(v **GetBucketTaggingOutput, decoder smithyxml.NodeDecoder) error { 4734 if v == nil { 4735 return fmt.Errorf("unexpected nil of type %T", v) 4736 } 4737 var sv *GetBucketTaggingOutput 4738 if *v == nil { 4739 sv = &GetBucketTaggingOutput{} 4740 } else { 4741 sv = *v 4742 } 4743 4744 for { 4745 t, done, err := decoder.Token() 4746 if err != nil { 4747 return err 4748 } 4749 if done { 4750 break 4751 } 4752 originalDecoder := decoder 4753 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4754 switch { 4755 case strings.EqualFold("TagSet", t.Name.Local): 4756 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 4757 if err := awsRestxml_deserializeDocumentTagSet(&sv.TagSet, nodeDecoder); err != nil { 4758 return err 4759 } 4760 4761 default: 4762 // Do nothing and ignore the unexpected tag element 4763 err = decoder.Decoder.Skip() 4764 if err != nil { 4765 return err 4766 } 4767 4768 } 4769 decoder = originalDecoder 4770 } 4771 *v = sv 4772 return nil 4773} 4774 4775type awsRestxml_deserializeOpGetBucketVersioning struct { 4776} 4777 4778func (*awsRestxml_deserializeOpGetBucketVersioning) ID() string { 4779 return "OperationDeserializer" 4780} 4781 4782func (m *awsRestxml_deserializeOpGetBucketVersioning) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4783 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4784) { 4785 out, metadata, err = next.HandleDeserialize(ctx, in) 4786 if err != nil { 4787 return out, metadata, err 4788 } 4789 4790 response, ok := out.RawResponse.(*smithyhttp.Response) 4791 if !ok { 4792 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4793 } 4794 4795 if response.StatusCode < 200 || response.StatusCode >= 300 { 4796 return out, metadata, awsRestxml_deserializeOpErrorGetBucketVersioning(response, &metadata) 4797 } 4798 output := &GetBucketVersioningOutput{} 4799 out.Result = output 4800 4801 var buff [1024]byte 4802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4803 body := io.TeeReader(response.Body, ringBuffer) 4804 rootDecoder := xml.NewDecoder(body) 4805 t, err := smithyxml.FetchRootElement(rootDecoder) 4806 if err == io.EOF { 4807 return out, metadata, nil 4808 } 4809 if err != nil { 4810 var snapshot bytes.Buffer 4811 io.Copy(&snapshot, ringBuffer) 4812 return out, metadata, &smithy.DeserializationError{ 4813 Err: fmt.Errorf("failed to decode response body, %w", err), 4814 Snapshot: snapshot.Bytes(), 4815 } 4816 } 4817 4818 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4819 err = awsRestxml_deserializeOpDocumentGetBucketVersioningOutput(&output, decoder) 4820 if err != nil { 4821 var snapshot bytes.Buffer 4822 io.Copy(&snapshot, ringBuffer) 4823 return out, metadata, &smithy.DeserializationError{ 4824 Err: fmt.Errorf("failed to decode response body, %w", err), 4825 Snapshot: snapshot.Bytes(), 4826 } 4827 } 4828 4829 return out, metadata, err 4830} 4831 4832func awsRestxml_deserializeOpErrorGetBucketVersioning(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4833 var errorBuffer bytes.Buffer 4834 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4835 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4836 } 4837 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4838 4839 errorCode := "UnknownError" 4840 errorMessage := errorCode 4841 4842 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 4843 UseStatusCode: true, StatusCode: response.StatusCode, 4844 }) 4845 if err != nil { 4846 return err 4847 } 4848 if hostID := errorComponents.HostID; len(hostID) != 0 { 4849 s3shared.SetHostIDMetadata(metadata, hostID) 4850 } 4851 if reqID := errorComponents.RequestID; len(reqID) != 0 { 4852 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 4853 } 4854 if len(errorComponents.Code) != 0 { 4855 errorCode = errorComponents.Code 4856 } 4857 if len(errorComponents.Message) != 0 { 4858 errorMessage = errorComponents.Message 4859 } 4860 errorBody.Seek(0, io.SeekStart) 4861 switch { 4862 default: 4863 genericError := &smithy.GenericAPIError{ 4864 Code: errorCode, 4865 Message: errorMessage, 4866 } 4867 return genericError 4868 4869 } 4870} 4871 4872func awsRestxml_deserializeOpDocumentGetBucketVersioningOutput(v **GetBucketVersioningOutput, decoder smithyxml.NodeDecoder) error { 4873 if v == nil { 4874 return fmt.Errorf("unexpected nil of type %T", v) 4875 } 4876 var sv *GetBucketVersioningOutput 4877 if *v == nil { 4878 sv = &GetBucketVersioningOutput{} 4879 } else { 4880 sv = *v 4881 } 4882 4883 for { 4884 t, done, err := decoder.Token() 4885 if err != nil { 4886 return err 4887 } 4888 if done { 4889 break 4890 } 4891 originalDecoder := decoder 4892 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 4893 switch { 4894 case strings.EqualFold("MfaDelete", t.Name.Local): 4895 val, err := decoder.Value() 4896 if err != nil { 4897 return err 4898 } 4899 if val == nil { 4900 break 4901 } 4902 { 4903 xtv := string(val) 4904 sv.MFADelete = types.MFADeleteStatus(xtv) 4905 } 4906 4907 case strings.EqualFold("Status", t.Name.Local): 4908 val, err := decoder.Value() 4909 if err != nil { 4910 return err 4911 } 4912 if val == nil { 4913 break 4914 } 4915 { 4916 xtv := string(val) 4917 sv.Status = types.BucketVersioningStatus(xtv) 4918 } 4919 4920 default: 4921 // Do nothing and ignore the unexpected tag element 4922 err = decoder.Decoder.Skip() 4923 if err != nil { 4924 return err 4925 } 4926 4927 } 4928 decoder = originalDecoder 4929 } 4930 *v = sv 4931 return nil 4932} 4933 4934type awsRestxml_deserializeOpGetBucketWebsite struct { 4935} 4936 4937func (*awsRestxml_deserializeOpGetBucketWebsite) ID() string { 4938 return "OperationDeserializer" 4939} 4940 4941func (m *awsRestxml_deserializeOpGetBucketWebsite) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4942 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4943) { 4944 out, metadata, err = next.HandleDeserialize(ctx, in) 4945 if err != nil { 4946 return out, metadata, err 4947 } 4948 4949 response, ok := out.RawResponse.(*smithyhttp.Response) 4950 if !ok { 4951 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4952 } 4953 4954 if response.StatusCode < 200 || response.StatusCode >= 300 { 4955 return out, metadata, awsRestxml_deserializeOpErrorGetBucketWebsite(response, &metadata) 4956 } 4957 output := &GetBucketWebsiteOutput{} 4958 out.Result = output 4959 4960 var buff [1024]byte 4961 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4962 body := io.TeeReader(response.Body, ringBuffer) 4963 rootDecoder := xml.NewDecoder(body) 4964 t, err := smithyxml.FetchRootElement(rootDecoder) 4965 if err == io.EOF { 4966 return out, metadata, nil 4967 } 4968 if err != nil { 4969 var snapshot bytes.Buffer 4970 io.Copy(&snapshot, ringBuffer) 4971 return out, metadata, &smithy.DeserializationError{ 4972 Err: fmt.Errorf("failed to decode response body, %w", err), 4973 Snapshot: snapshot.Bytes(), 4974 } 4975 } 4976 4977 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 4978 err = awsRestxml_deserializeOpDocumentGetBucketWebsiteOutput(&output, decoder) 4979 if err != nil { 4980 var snapshot bytes.Buffer 4981 io.Copy(&snapshot, ringBuffer) 4982 return out, metadata, &smithy.DeserializationError{ 4983 Err: fmt.Errorf("failed to decode response body, %w", err), 4984 Snapshot: snapshot.Bytes(), 4985 } 4986 } 4987 4988 return out, metadata, err 4989} 4990 4991func awsRestxml_deserializeOpErrorGetBucketWebsite(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4992 var errorBuffer bytes.Buffer 4993 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4994 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4995 } 4996 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4997 4998 errorCode := "UnknownError" 4999 errorMessage := errorCode 5000 5001 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5002 UseStatusCode: true, StatusCode: response.StatusCode, 5003 }) 5004 if err != nil { 5005 return err 5006 } 5007 if hostID := errorComponents.HostID; len(hostID) != 0 { 5008 s3shared.SetHostIDMetadata(metadata, hostID) 5009 } 5010 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5011 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5012 } 5013 if len(errorComponents.Code) != 0 { 5014 errorCode = errorComponents.Code 5015 } 5016 if len(errorComponents.Message) != 0 { 5017 errorMessage = errorComponents.Message 5018 } 5019 errorBody.Seek(0, io.SeekStart) 5020 switch { 5021 default: 5022 genericError := &smithy.GenericAPIError{ 5023 Code: errorCode, 5024 Message: errorMessage, 5025 } 5026 return genericError 5027 5028 } 5029} 5030 5031func awsRestxml_deserializeOpDocumentGetBucketWebsiteOutput(v **GetBucketWebsiteOutput, decoder smithyxml.NodeDecoder) error { 5032 if v == nil { 5033 return fmt.Errorf("unexpected nil of type %T", v) 5034 } 5035 var sv *GetBucketWebsiteOutput 5036 if *v == nil { 5037 sv = &GetBucketWebsiteOutput{} 5038 } else { 5039 sv = *v 5040 } 5041 5042 for { 5043 t, done, err := decoder.Token() 5044 if err != nil { 5045 return err 5046 } 5047 if done { 5048 break 5049 } 5050 originalDecoder := decoder 5051 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5052 switch { 5053 case strings.EqualFold("ErrorDocument", t.Name.Local): 5054 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5055 if err := awsRestxml_deserializeDocumentErrorDocument(&sv.ErrorDocument, nodeDecoder); err != nil { 5056 return err 5057 } 5058 5059 case strings.EqualFold("IndexDocument", t.Name.Local): 5060 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5061 if err := awsRestxml_deserializeDocumentIndexDocument(&sv.IndexDocument, nodeDecoder); err != nil { 5062 return err 5063 } 5064 5065 case strings.EqualFold("RedirectAllRequestsTo", t.Name.Local): 5066 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5067 if err := awsRestxml_deserializeDocumentRedirectAllRequestsTo(&sv.RedirectAllRequestsTo, nodeDecoder); err != nil { 5068 return err 5069 } 5070 5071 case strings.EqualFold("RoutingRules", t.Name.Local): 5072 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5073 if err := awsRestxml_deserializeDocumentRoutingRules(&sv.RoutingRules, nodeDecoder); err != nil { 5074 return err 5075 } 5076 5077 default: 5078 // Do nothing and ignore the unexpected tag element 5079 err = decoder.Decoder.Skip() 5080 if err != nil { 5081 return err 5082 } 5083 5084 } 5085 decoder = originalDecoder 5086 } 5087 *v = sv 5088 return nil 5089} 5090 5091type awsRestxml_deserializeOpGetObject struct { 5092} 5093 5094func (*awsRestxml_deserializeOpGetObject) ID() string { 5095 return "OperationDeserializer" 5096} 5097 5098func (m *awsRestxml_deserializeOpGetObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5099 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5100) { 5101 out, metadata, err = next.HandleDeserialize(ctx, in) 5102 if err != nil { 5103 return out, metadata, err 5104 } 5105 5106 response, ok := out.RawResponse.(*smithyhttp.Response) 5107 if !ok { 5108 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5109 } 5110 5111 if response.StatusCode < 200 || response.StatusCode >= 300 { 5112 return out, metadata, awsRestxml_deserializeOpErrorGetObject(response, &metadata) 5113 } 5114 output := &GetObjectOutput{} 5115 out.Result = output 5116 5117 err = awsRestxml_deserializeOpHttpBindingsGetObjectOutput(output, response) 5118 if err != nil { 5119 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5120 } 5121 5122 err = awsRestxml_deserializeOpDocumentGetObjectOutput(output, response.Body) 5123 if err != nil { 5124 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 5125 } 5126 5127 return out, metadata, err 5128} 5129 5130func awsRestxml_deserializeOpErrorGetObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5131 var errorBuffer bytes.Buffer 5132 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5133 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5134 } 5135 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5136 5137 errorCode := "UnknownError" 5138 errorMessage := errorCode 5139 5140 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5141 UseStatusCode: true, StatusCode: response.StatusCode, 5142 }) 5143 if err != nil { 5144 return err 5145 } 5146 if hostID := errorComponents.HostID; len(hostID) != 0 { 5147 s3shared.SetHostIDMetadata(metadata, hostID) 5148 } 5149 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5150 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5151 } 5152 if len(errorComponents.Code) != 0 { 5153 errorCode = errorComponents.Code 5154 } 5155 if len(errorComponents.Message) != 0 { 5156 errorMessage = errorComponents.Message 5157 } 5158 errorBody.Seek(0, io.SeekStart) 5159 switch { 5160 case strings.EqualFold("InvalidObjectState", errorCode): 5161 return awsRestxml_deserializeErrorInvalidObjectState(response, errorBody) 5162 5163 case strings.EqualFold("NoSuchKey", errorCode): 5164 return awsRestxml_deserializeErrorNoSuchKey(response, errorBody) 5165 5166 default: 5167 genericError := &smithy.GenericAPIError{ 5168 Code: errorCode, 5169 Message: errorMessage, 5170 } 5171 return genericError 5172 5173 } 5174} 5175 5176func awsRestxml_deserializeOpHttpBindingsGetObjectOutput(v *GetObjectOutput, response *smithyhttp.Response) error { 5177 if v == nil { 5178 return fmt.Errorf("unsupported deserialization for nil %T", v) 5179 } 5180 5181 if headerValues := response.Header.Values("accept-ranges"); len(headerValues) != 0 { 5182 headerValues[0] = strings.TrimSpace(headerValues[0]) 5183 v.AcceptRanges = ptr.String(headerValues[0]) 5184 } 5185 5186 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 5187 headerValues[0] = strings.TrimSpace(headerValues[0]) 5188 vv, err := strconv.ParseBool(headerValues[0]) 5189 if err != nil { 5190 return err 5191 } 5192 v.BucketKeyEnabled = vv 5193 } 5194 5195 if headerValues := response.Header.Values("Cache-Control"); len(headerValues) != 0 { 5196 headerValues[0] = strings.TrimSpace(headerValues[0]) 5197 v.CacheControl = ptr.String(headerValues[0]) 5198 } 5199 5200 if headerValues := response.Header.Values("Content-Disposition"); len(headerValues) != 0 { 5201 headerValues[0] = strings.TrimSpace(headerValues[0]) 5202 v.ContentDisposition = ptr.String(headerValues[0]) 5203 } 5204 5205 if headerValues := response.Header.Values("Content-Encoding"); len(headerValues) != 0 { 5206 headerValues[0] = strings.TrimSpace(headerValues[0]) 5207 v.ContentEncoding = ptr.String(headerValues[0]) 5208 } 5209 5210 if headerValues := response.Header.Values("Content-Language"); len(headerValues) != 0 { 5211 headerValues[0] = strings.TrimSpace(headerValues[0]) 5212 v.ContentLanguage = ptr.String(headerValues[0]) 5213 } 5214 5215 if headerValues := response.Header.Values("Content-Length"); len(headerValues) != 0 { 5216 headerValues[0] = strings.TrimSpace(headerValues[0]) 5217 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 5218 if err != nil { 5219 return err 5220 } 5221 v.ContentLength = vv 5222 } 5223 5224 if headerValues := response.Header.Values("Content-Range"); len(headerValues) != 0 { 5225 headerValues[0] = strings.TrimSpace(headerValues[0]) 5226 v.ContentRange = ptr.String(headerValues[0]) 5227 } 5228 5229 if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { 5230 headerValues[0] = strings.TrimSpace(headerValues[0]) 5231 v.ContentType = ptr.String(headerValues[0]) 5232 } 5233 5234 if headerValues := response.Header.Values("x-amz-delete-marker"); len(headerValues) != 0 { 5235 headerValues[0] = strings.TrimSpace(headerValues[0]) 5236 vv, err := strconv.ParseBool(headerValues[0]) 5237 if err != nil { 5238 return err 5239 } 5240 v.DeleteMarker = vv 5241 } 5242 5243 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 5244 headerValues[0] = strings.TrimSpace(headerValues[0]) 5245 v.ETag = ptr.String(headerValues[0]) 5246 } 5247 5248 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 5249 headerValues[0] = strings.TrimSpace(headerValues[0]) 5250 v.Expiration = ptr.String(headerValues[0]) 5251 } 5252 5253 if headerValues := response.Header.Values("Expires"); len(headerValues) != 0 { 5254 headerValues[0] = strings.TrimSpace(headerValues[0]) 5255 t, err := smithytime.ParseHTTPDate(headerValues[0]) 5256 if err != nil { 5257 return err 5258 } 5259 v.Expires = ptr.Time(t) 5260 } 5261 5262 if headerValues := response.Header.Values("Last-Modified"); len(headerValues) != 0 { 5263 headerValues[0] = strings.TrimSpace(headerValues[0]) 5264 t, err := smithytime.ParseHTTPDate(headerValues[0]) 5265 if err != nil { 5266 return err 5267 } 5268 v.LastModified = ptr.Time(t) 5269 } 5270 5271 for headerKey, headerValues := range response.Header { 5272 if lenPrefix := len("x-amz-meta-"); len(headerKey) >= lenPrefix && strings.EqualFold(headerKey[:lenPrefix], "x-amz-meta-") { 5273 if v.Metadata == nil { 5274 v.Metadata = map[string]string{} 5275 } 5276 headerValues[0] = strings.TrimSpace(headerValues[0]) 5277 v.Metadata[strings.ToLower(headerKey[lenPrefix:])] = headerValues[0] 5278 } 5279 } 5280 5281 if headerValues := response.Header.Values("x-amz-missing-meta"); len(headerValues) != 0 { 5282 headerValues[0] = strings.TrimSpace(headerValues[0]) 5283 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 5284 if err != nil { 5285 return err 5286 } 5287 v.MissingMeta = int32(vv) 5288 } 5289 5290 if headerValues := response.Header.Values("x-amz-object-lock-legal-hold"); len(headerValues) != 0 { 5291 headerValues[0] = strings.TrimSpace(headerValues[0]) 5292 v.ObjectLockLegalHoldStatus = types.ObjectLockLegalHoldStatus(headerValues[0]) 5293 } 5294 5295 if headerValues := response.Header.Values("x-amz-object-lock-mode"); len(headerValues) != 0 { 5296 headerValues[0] = strings.TrimSpace(headerValues[0]) 5297 v.ObjectLockMode = types.ObjectLockMode(headerValues[0]) 5298 } 5299 5300 if headerValues := response.Header.Values("x-amz-object-lock-retain-until-date"); len(headerValues) != 0 { 5301 headerValues[0] = strings.TrimSpace(headerValues[0]) 5302 t, err := smithytime.ParseDateTime(headerValues[0]) 5303 if err != nil { 5304 return err 5305 } 5306 v.ObjectLockRetainUntilDate = ptr.Time(t) 5307 } 5308 5309 if headerValues := response.Header.Values("x-amz-mp-parts-count"); len(headerValues) != 0 { 5310 headerValues[0] = strings.TrimSpace(headerValues[0]) 5311 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 5312 if err != nil { 5313 return err 5314 } 5315 v.PartsCount = int32(vv) 5316 } 5317 5318 if headerValues := response.Header.Values("x-amz-replication-status"); len(headerValues) != 0 { 5319 headerValues[0] = strings.TrimSpace(headerValues[0]) 5320 v.ReplicationStatus = types.ReplicationStatus(headerValues[0]) 5321 } 5322 5323 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 5324 headerValues[0] = strings.TrimSpace(headerValues[0]) 5325 v.RequestCharged = types.RequestCharged(headerValues[0]) 5326 } 5327 5328 if headerValues := response.Header.Values("x-amz-restore"); len(headerValues) != 0 { 5329 headerValues[0] = strings.TrimSpace(headerValues[0]) 5330 v.Restore = ptr.String(headerValues[0]) 5331 } 5332 5333 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 5334 headerValues[0] = strings.TrimSpace(headerValues[0]) 5335 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 5336 } 5337 5338 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 5339 headerValues[0] = strings.TrimSpace(headerValues[0]) 5340 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 5341 } 5342 5343 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 5344 headerValues[0] = strings.TrimSpace(headerValues[0]) 5345 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 5346 } 5347 5348 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 5349 headerValues[0] = strings.TrimSpace(headerValues[0]) 5350 v.SSEKMSKeyId = ptr.String(headerValues[0]) 5351 } 5352 5353 if headerValues := response.Header.Values("x-amz-storage-class"); len(headerValues) != 0 { 5354 headerValues[0] = strings.TrimSpace(headerValues[0]) 5355 v.StorageClass = types.StorageClass(headerValues[0]) 5356 } 5357 5358 if headerValues := response.Header.Values("x-amz-tagging-count"); len(headerValues) != 0 { 5359 headerValues[0] = strings.TrimSpace(headerValues[0]) 5360 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 5361 if err != nil { 5362 return err 5363 } 5364 v.TagCount = int32(vv) 5365 } 5366 5367 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 5368 headerValues[0] = strings.TrimSpace(headerValues[0]) 5369 v.VersionId = ptr.String(headerValues[0]) 5370 } 5371 5372 if headerValues := response.Header.Values("x-amz-website-redirect-location"); len(headerValues) != 0 { 5373 headerValues[0] = strings.TrimSpace(headerValues[0]) 5374 v.WebsiteRedirectLocation = ptr.String(headerValues[0]) 5375 } 5376 5377 return nil 5378} 5379func awsRestxml_deserializeOpDocumentGetObjectOutput(v *GetObjectOutput, body io.ReadCloser) error { 5380 if v == nil { 5381 return fmt.Errorf("unsupported deserialization of nil %T", v) 5382 } 5383 v.Body = body 5384 return nil 5385} 5386 5387type awsRestxml_deserializeOpGetObjectAcl struct { 5388} 5389 5390func (*awsRestxml_deserializeOpGetObjectAcl) ID() string { 5391 return "OperationDeserializer" 5392} 5393 5394func (m *awsRestxml_deserializeOpGetObjectAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5395 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5396) { 5397 out, metadata, err = next.HandleDeserialize(ctx, in) 5398 if err != nil { 5399 return out, metadata, err 5400 } 5401 5402 response, ok := out.RawResponse.(*smithyhttp.Response) 5403 if !ok { 5404 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5405 } 5406 5407 if response.StatusCode < 200 || response.StatusCode >= 300 { 5408 return out, metadata, awsRestxml_deserializeOpErrorGetObjectAcl(response, &metadata) 5409 } 5410 output := &GetObjectAclOutput{} 5411 out.Result = output 5412 5413 err = awsRestxml_deserializeOpHttpBindingsGetObjectAclOutput(output, response) 5414 if err != nil { 5415 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5416 } 5417 5418 var buff [1024]byte 5419 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5420 body := io.TeeReader(response.Body, ringBuffer) 5421 rootDecoder := xml.NewDecoder(body) 5422 t, err := smithyxml.FetchRootElement(rootDecoder) 5423 if err == io.EOF { 5424 return out, metadata, nil 5425 } 5426 if err != nil { 5427 var snapshot bytes.Buffer 5428 io.Copy(&snapshot, ringBuffer) 5429 return out, metadata, &smithy.DeserializationError{ 5430 Err: fmt.Errorf("failed to decode response body, %w", err), 5431 Snapshot: snapshot.Bytes(), 5432 } 5433 } 5434 5435 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5436 err = awsRestxml_deserializeOpDocumentGetObjectAclOutput(&output, decoder) 5437 if err != nil { 5438 var snapshot bytes.Buffer 5439 io.Copy(&snapshot, ringBuffer) 5440 return out, metadata, &smithy.DeserializationError{ 5441 Err: fmt.Errorf("failed to decode response body, %w", err), 5442 Snapshot: snapshot.Bytes(), 5443 } 5444 } 5445 5446 return out, metadata, err 5447} 5448 5449func awsRestxml_deserializeOpErrorGetObjectAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5450 var errorBuffer bytes.Buffer 5451 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5452 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5453 } 5454 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5455 5456 errorCode := "UnknownError" 5457 errorMessage := errorCode 5458 5459 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5460 UseStatusCode: true, StatusCode: response.StatusCode, 5461 }) 5462 if err != nil { 5463 return err 5464 } 5465 if hostID := errorComponents.HostID; len(hostID) != 0 { 5466 s3shared.SetHostIDMetadata(metadata, hostID) 5467 } 5468 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5469 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5470 } 5471 if len(errorComponents.Code) != 0 { 5472 errorCode = errorComponents.Code 5473 } 5474 if len(errorComponents.Message) != 0 { 5475 errorMessage = errorComponents.Message 5476 } 5477 errorBody.Seek(0, io.SeekStart) 5478 switch { 5479 case strings.EqualFold("NoSuchKey", errorCode): 5480 return awsRestxml_deserializeErrorNoSuchKey(response, errorBody) 5481 5482 default: 5483 genericError := &smithy.GenericAPIError{ 5484 Code: errorCode, 5485 Message: errorMessage, 5486 } 5487 return genericError 5488 5489 } 5490} 5491 5492func awsRestxml_deserializeOpHttpBindingsGetObjectAclOutput(v *GetObjectAclOutput, response *smithyhttp.Response) error { 5493 if v == nil { 5494 return fmt.Errorf("unsupported deserialization for nil %T", v) 5495 } 5496 5497 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 5498 headerValues[0] = strings.TrimSpace(headerValues[0]) 5499 v.RequestCharged = types.RequestCharged(headerValues[0]) 5500 } 5501 5502 return nil 5503} 5504func awsRestxml_deserializeOpDocumentGetObjectAclOutput(v **GetObjectAclOutput, decoder smithyxml.NodeDecoder) error { 5505 if v == nil { 5506 return fmt.Errorf("unexpected nil of type %T", v) 5507 } 5508 var sv *GetObjectAclOutput 5509 if *v == nil { 5510 sv = &GetObjectAclOutput{} 5511 } else { 5512 sv = *v 5513 } 5514 5515 for { 5516 t, done, err := decoder.Token() 5517 if err != nil { 5518 return err 5519 } 5520 if done { 5521 break 5522 } 5523 originalDecoder := decoder 5524 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5525 switch { 5526 case strings.EqualFold("AccessControlList", t.Name.Local): 5527 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5528 if err := awsRestxml_deserializeDocumentGrants(&sv.Grants, nodeDecoder); err != nil { 5529 return err 5530 } 5531 5532 case strings.EqualFold("Owner", t.Name.Local): 5533 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5534 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 5535 return err 5536 } 5537 5538 default: 5539 // Do nothing and ignore the unexpected tag element 5540 err = decoder.Decoder.Skip() 5541 if err != nil { 5542 return err 5543 } 5544 5545 } 5546 decoder = originalDecoder 5547 } 5548 *v = sv 5549 return nil 5550} 5551 5552type awsRestxml_deserializeOpGetObjectLegalHold struct { 5553} 5554 5555func (*awsRestxml_deserializeOpGetObjectLegalHold) ID() string { 5556 return "OperationDeserializer" 5557} 5558 5559func (m *awsRestxml_deserializeOpGetObjectLegalHold) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5560 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5561) { 5562 out, metadata, err = next.HandleDeserialize(ctx, in) 5563 if err != nil { 5564 return out, metadata, err 5565 } 5566 5567 response, ok := out.RawResponse.(*smithyhttp.Response) 5568 if !ok { 5569 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5570 } 5571 5572 if response.StatusCode < 200 || response.StatusCode >= 300 { 5573 return out, metadata, awsRestxml_deserializeOpErrorGetObjectLegalHold(response, &metadata) 5574 } 5575 output := &GetObjectLegalHoldOutput{} 5576 out.Result = output 5577 5578 var buff [1024]byte 5579 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5580 body := io.TeeReader(response.Body, ringBuffer) 5581 rootDecoder := xml.NewDecoder(body) 5582 t, err := smithyxml.FetchRootElement(rootDecoder) 5583 if err == io.EOF { 5584 return out, metadata, nil 5585 } 5586 if err != nil { 5587 var snapshot bytes.Buffer 5588 io.Copy(&snapshot, ringBuffer) 5589 return out, metadata, &smithy.DeserializationError{ 5590 Err: fmt.Errorf("failed to decode response body, %w", err), 5591 Snapshot: snapshot.Bytes(), 5592 } 5593 } 5594 5595 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5596 err = awsRestxml_deserializeDocumentObjectLockLegalHold(&output.LegalHold, decoder) 5597 if err != nil { 5598 var snapshot bytes.Buffer 5599 io.Copy(&snapshot, ringBuffer) 5600 return out, metadata, &smithy.DeserializationError{ 5601 Err: fmt.Errorf("failed to decode response body, %w", err), 5602 Snapshot: snapshot.Bytes(), 5603 } 5604 } 5605 5606 return out, metadata, err 5607} 5608 5609func awsRestxml_deserializeOpErrorGetObjectLegalHold(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5610 var errorBuffer bytes.Buffer 5611 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5612 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5613 } 5614 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5615 5616 errorCode := "UnknownError" 5617 errorMessage := errorCode 5618 5619 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5620 UseStatusCode: true, StatusCode: response.StatusCode, 5621 }) 5622 if err != nil { 5623 return err 5624 } 5625 if hostID := errorComponents.HostID; len(hostID) != 0 { 5626 s3shared.SetHostIDMetadata(metadata, hostID) 5627 } 5628 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5629 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5630 } 5631 if len(errorComponents.Code) != 0 { 5632 errorCode = errorComponents.Code 5633 } 5634 if len(errorComponents.Message) != 0 { 5635 errorMessage = errorComponents.Message 5636 } 5637 errorBody.Seek(0, io.SeekStart) 5638 switch { 5639 default: 5640 genericError := &smithy.GenericAPIError{ 5641 Code: errorCode, 5642 Message: errorMessage, 5643 } 5644 return genericError 5645 5646 } 5647} 5648 5649func awsRestxml_deserializeOpDocumentGetObjectLegalHoldOutput(v **GetObjectLegalHoldOutput, decoder smithyxml.NodeDecoder) error { 5650 if v == nil { 5651 return fmt.Errorf("unexpected nil of type %T", v) 5652 } 5653 var sv *GetObjectLegalHoldOutput 5654 if *v == nil { 5655 sv = &GetObjectLegalHoldOutput{} 5656 } else { 5657 sv = *v 5658 } 5659 5660 for { 5661 t, done, err := decoder.Token() 5662 if err != nil { 5663 return err 5664 } 5665 if done { 5666 break 5667 } 5668 originalDecoder := decoder 5669 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5670 switch { 5671 case strings.EqualFold("LegalHold", t.Name.Local): 5672 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5673 if err := awsRestxml_deserializeDocumentObjectLockLegalHold(&sv.LegalHold, nodeDecoder); err != nil { 5674 return err 5675 } 5676 5677 default: 5678 // Do nothing and ignore the unexpected tag element 5679 err = decoder.Decoder.Skip() 5680 if err != nil { 5681 return err 5682 } 5683 5684 } 5685 decoder = originalDecoder 5686 } 5687 *v = sv 5688 return nil 5689} 5690 5691type awsRestxml_deserializeOpGetObjectLockConfiguration struct { 5692} 5693 5694func (*awsRestxml_deserializeOpGetObjectLockConfiguration) ID() string { 5695 return "OperationDeserializer" 5696} 5697 5698func (m *awsRestxml_deserializeOpGetObjectLockConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5699 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5700) { 5701 out, metadata, err = next.HandleDeserialize(ctx, in) 5702 if err != nil { 5703 return out, metadata, err 5704 } 5705 5706 response, ok := out.RawResponse.(*smithyhttp.Response) 5707 if !ok { 5708 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5709 } 5710 5711 if response.StatusCode < 200 || response.StatusCode >= 300 { 5712 return out, metadata, awsRestxml_deserializeOpErrorGetObjectLockConfiguration(response, &metadata) 5713 } 5714 output := &GetObjectLockConfigurationOutput{} 5715 out.Result = output 5716 5717 var buff [1024]byte 5718 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5719 body := io.TeeReader(response.Body, ringBuffer) 5720 rootDecoder := xml.NewDecoder(body) 5721 t, err := smithyxml.FetchRootElement(rootDecoder) 5722 if err == io.EOF { 5723 return out, metadata, nil 5724 } 5725 if err != nil { 5726 var snapshot bytes.Buffer 5727 io.Copy(&snapshot, ringBuffer) 5728 return out, metadata, &smithy.DeserializationError{ 5729 Err: fmt.Errorf("failed to decode response body, %w", err), 5730 Snapshot: snapshot.Bytes(), 5731 } 5732 } 5733 5734 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5735 err = awsRestxml_deserializeDocumentObjectLockConfiguration(&output.ObjectLockConfiguration, decoder) 5736 if err != nil { 5737 var snapshot bytes.Buffer 5738 io.Copy(&snapshot, ringBuffer) 5739 return out, metadata, &smithy.DeserializationError{ 5740 Err: fmt.Errorf("failed to decode response body, %w", err), 5741 Snapshot: snapshot.Bytes(), 5742 } 5743 } 5744 5745 return out, metadata, err 5746} 5747 5748func awsRestxml_deserializeOpErrorGetObjectLockConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5749 var errorBuffer bytes.Buffer 5750 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5751 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5752 } 5753 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5754 5755 errorCode := "UnknownError" 5756 errorMessage := errorCode 5757 5758 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5759 UseStatusCode: true, StatusCode: response.StatusCode, 5760 }) 5761 if err != nil { 5762 return err 5763 } 5764 if hostID := errorComponents.HostID; len(hostID) != 0 { 5765 s3shared.SetHostIDMetadata(metadata, hostID) 5766 } 5767 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5768 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5769 } 5770 if len(errorComponents.Code) != 0 { 5771 errorCode = errorComponents.Code 5772 } 5773 if len(errorComponents.Message) != 0 { 5774 errorMessage = errorComponents.Message 5775 } 5776 errorBody.Seek(0, io.SeekStart) 5777 switch { 5778 default: 5779 genericError := &smithy.GenericAPIError{ 5780 Code: errorCode, 5781 Message: errorMessage, 5782 } 5783 return genericError 5784 5785 } 5786} 5787 5788func awsRestxml_deserializeOpDocumentGetObjectLockConfigurationOutput(v **GetObjectLockConfigurationOutput, decoder smithyxml.NodeDecoder) error { 5789 if v == nil { 5790 return fmt.Errorf("unexpected nil of type %T", v) 5791 } 5792 var sv *GetObjectLockConfigurationOutput 5793 if *v == nil { 5794 sv = &GetObjectLockConfigurationOutput{} 5795 } else { 5796 sv = *v 5797 } 5798 5799 for { 5800 t, done, err := decoder.Token() 5801 if err != nil { 5802 return err 5803 } 5804 if done { 5805 break 5806 } 5807 originalDecoder := decoder 5808 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5809 switch { 5810 case strings.EqualFold("ObjectLockConfiguration", t.Name.Local): 5811 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5812 if err := awsRestxml_deserializeDocumentObjectLockConfiguration(&sv.ObjectLockConfiguration, nodeDecoder); err != nil { 5813 return err 5814 } 5815 5816 default: 5817 // Do nothing and ignore the unexpected tag element 5818 err = decoder.Decoder.Skip() 5819 if err != nil { 5820 return err 5821 } 5822 5823 } 5824 decoder = originalDecoder 5825 } 5826 *v = sv 5827 return nil 5828} 5829 5830type awsRestxml_deserializeOpGetObjectRetention struct { 5831} 5832 5833func (*awsRestxml_deserializeOpGetObjectRetention) ID() string { 5834 return "OperationDeserializer" 5835} 5836 5837func (m *awsRestxml_deserializeOpGetObjectRetention) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5838 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5839) { 5840 out, metadata, err = next.HandleDeserialize(ctx, in) 5841 if err != nil { 5842 return out, metadata, err 5843 } 5844 5845 response, ok := out.RawResponse.(*smithyhttp.Response) 5846 if !ok { 5847 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5848 } 5849 5850 if response.StatusCode < 200 || response.StatusCode >= 300 { 5851 return out, metadata, awsRestxml_deserializeOpErrorGetObjectRetention(response, &metadata) 5852 } 5853 output := &GetObjectRetentionOutput{} 5854 out.Result = output 5855 5856 var buff [1024]byte 5857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5858 body := io.TeeReader(response.Body, ringBuffer) 5859 rootDecoder := xml.NewDecoder(body) 5860 t, err := smithyxml.FetchRootElement(rootDecoder) 5861 if err == io.EOF { 5862 return out, metadata, nil 5863 } 5864 if err != nil { 5865 var snapshot bytes.Buffer 5866 io.Copy(&snapshot, ringBuffer) 5867 return out, metadata, &smithy.DeserializationError{ 5868 Err: fmt.Errorf("failed to decode response body, %w", err), 5869 Snapshot: snapshot.Bytes(), 5870 } 5871 } 5872 5873 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 5874 err = awsRestxml_deserializeDocumentObjectLockRetention(&output.Retention, decoder) 5875 if err != nil { 5876 var snapshot bytes.Buffer 5877 io.Copy(&snapshot, ringBuffer) 5878 return out, metadata, &smithy.DeserializationError{ 5879 Err: fmt.Errorf("failed to decode response body, %w", err), 5880 Snapshot: snapshot.Bytes(), 5881 } 5882 } 5883 5884 return out, metadata, err 5885} 5886 5887func awsRestxml_deserializeOpErrorGetObjectRetention(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5888 var errorBuffer bytes.Buffer 5889 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5890 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5891 } 5892 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5893 5894 errorCode := "UnknownError" 5895 errorMessage := errorCode 5896 5897 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 5898 UseStatusCode: true, StatusCode: response.StatusCode, 5899 }) 5900 if err != nil { 5901 return err 5902 } 5903 if hostID := errorComponents.HostID; len(hostID) != 0 { 5904 s3shared.SetHostIDMetadata(metadata, hostID) 5905 } 5906 if reqID := errorComponents.RequestID; len(reqID) != 0 { 5907 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 5908 } 5909 if len(errorComponents.Code) != 0 { 5910 errorCode = errorComponents.Code 5911 } 5912 if len(errorComponents.Message) != 0 { 5913 errorMessage = errorComponents.Message 5914 } 5915 errorBody.Seek(0, io.SeekStart) 5916 switch { 5917 default: 5918 genericError := &smithy.GenericAPIError{ 5919 Code: errorCode, 5920 Message: errorMessage, 5921 } 5922 return genericError 5923 5924 } 5925} 5926 5927func awsRestxml_deserializeOpDocumentGetObjectRetentionOutput(v **GetObjectRetentionOutput, decoder smithyxml.NodeDecoder) error { 5928 if v == nil { 5929 return fmt.Errorf("unexpected nil of type %T", v) 5930 } 5931 var sv *GetObjectRetentionOutput 5932 if *v == nil { 5933 sv = &GetObjectRetentionOutput{} 5934 } else { 5935 sv = *v 5936 } 5937 5938 for { 5939 t, done, err := decoder.Token() 5940 if err != nil { 5941 return err 5942 } 5943 if done { 5944 break 5945 } 5946 originalDecoder := decoder 5947 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 5948 switch { 5949 case strings.EqualFold("Retention", t.Name.Local): 5950 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 5951 if err := awsRestxml_deserializeDocumentObjectLockRetention(&sv.Retention, nodeDecoder); err != nil { 5952 return err 5953 } 5954 5955 default: 5956 // Do nothing and ignore the unexpected tag element 5957 err = decoder.Decoder.Skip() 5958 if err != nil { 5959 return err 5960 } 5961 5962 } 5963 decoder = originalDecoder 5964 } 5965 *v = sv 5966 return nil 5967} 5968 5969type awsRestxml_deserializeOpGetObjectTagging struct { 5970} 5971 5972func (*awsRestxml_deserializeOpGetObjectTagging) ID() string { 5973 return "OperationDeserializer" 5974} 5975 5976func (m *awsRestxml_deserializeOpGetObjectTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5977 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5978) { 5979 out, metadata, err = next.HandleDeserialize(ctx, in) 5980 if err != nil { 5981 return out, metadata, err 5982 } 5983 5984 response, ok := out.RawResponse.(*smithyhttp.Response) 5985 if !ok { 5986 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5987 } 5988 5989 if response.StatusCode < 200 || response.StatusCode >= 300 { 5990 return out, metadata, awsRestxml_deserializeOpErrorGetObjectTagging(response, &metadata) 5991 } 5992 output := &GetObjectTaggingOutput{} 5993 out.Result = output 5994 5995 err = awsRestxml_deserializeOpHttpBindingsGetObjectTaggingOutput(output, response) 5996 if err != nil { 5997 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 5998 } 5999 6000 var buff [1024]byte 6001 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6002 body := io.TeeReader(response.Body, ringBuffer) 6003 rootDecoder := xml.NewDecoder(body) 6004 t, err := smithyxml.FetchRootElement(rootDecoder) 6005 if err == io.EOF { 6006 return out, metadata, nil 6007 } 6008 if err != nil { 6009 var snapshot bytes.Buffer 6010 io.Copy(&snapshot, ringBuffer) 6011 return out, metadata, &smithy.DeserializationError{ 6012 Err: fmt.Errorf("failed to decode response body, %w", err), 6013 Snapshot: snapshot.Bytes(), 6014 } 6015 } 6016 6017 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6018 err = awsRestxml_deserializeOpDocumentGetObjectTaggingOutput(&output, decoder) 6019 if err != nil { 6020 var snapshot bytes.Buffer 6021 io.Copy(&snapshot, ringBuffer) 6022 return out, metadata, &smithy.DeserializationError{ 6023 Err: fmt.Errorf("failed to decode response body, %w", err), 6024 Snapshot: snapshot.Bytes(), 6025 } 6026 } 6027 6028 return out, metadata, err 6029} 6030 6031func awsRestxml_deserializeOpErrorGetObjectTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6032 var errorBuffer bytes.Buffer 6033 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6034 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6035 } 6036 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6037 6038 errorCode := "UnknownError" 6039 errorMessage := errorCode 6040 6041 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6042 UseStatusCode: true, StatusCode: response.StatusCode, 6043 }) 6044 if err != nil { 6045 return err 6046 } 6047 if hostID := errorComponents.HostID; len(hostID) != 0 { 6048 s3shared.SetHostIDMetadata(metadata, hostID) 6049 } 6050 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6051 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6052 } 6053 if len(errorComponents.Code) != 0 { 6054 errorCode = errorComponents.Code 6055 } 6056 if len(errorComponents.Message) != 0 { 6057 errorMessage = errorComponents.Message 6058 } 6059 errorBody.Seek(0, io.SeekStart) 6060 switch { 6061 default: 6062 genericError := &smithy.GenericAPIError{ 6063 Code: errorCode, 6064 Message: errorMessage, 6065 } 6066 return genericError 6067 6068 } 6069} 6070 6071func awsRestxml_deserializeOpHttpBindingsGetObjectTaggingOutput(v *GetObjectTaggingOutput, response *smithyhttp.Response) error { 6072 if v == nil { 6073 return fmt.Errorf("unsupported deserialization for nil %T", v) 6074 } 6075 6076 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 6077 headerValues[0] = strings.TrimSpace(headerValues[0]) 6078 v.VersionId = ptr.String(headerValues[0]) 6079 } 6080 6081 return nil 6082} 6083func awsRestxml_deserializeOpDocumentGetObjectTaggingOutput(v **GetObjectTaggingOutput, decoder smithyxml.NodeDecoder) error { 6084 if v == nil { 6085 return fmt.Errorf("unexpected nil of type %T", v) 6086 } 6087 var sv *GetObjectTaggingOutput 6088 if *v == nil { 6089 sv = &GetObjectTaggingOutput{} 6090 } else { 6091 sv = *v 6092 } 6093 6094 for { 6095 t, done, err := decoder.Token() 6096 if err != nil { 6097 return err 6098 } 6099 if done { 6100 break 6101 } 6102 originalDecoder := decoder 6103 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6104 switch { 6105 case strings.EqualFold("TagSet", t.Name.Local): 6106 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6107 if err := awsRestxml_deserializeDocumentTagSet(&sv.TagSet, nodeDecoder); err != nil { 6108 return err 6109 } 6110 6111 default: 6112 // Do nothing and ignore the unexpected tag element 6113 err = decoder.Decoder.Skip() 6114 if err != nil { 6115 return err 6116 } 6117 6118 } 6119 decoder = originalDecoder 6120 } 6121 *v = sv 6122 return nil 6123} 6124 6125type awsRestxml_deserializeOpGetObjectTorrent struct { 6126} 6127 6128func (*awsRestxml_deserializeOpGetObjectTorrent) ID() string { 6129 return "OperationDeserializer" 6130} 6131 6132func (m *awsRestxml_deserializeOpGetObjectTorrent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6133 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6134) { 6135 out, metadata, err = next.HandleDeserialize(ctx, in) 6136 if err != nil { 6137 return out, metadata, err 6138 } 6139 6140 response, ok := out.RawResponse.(*smithyhttp.Response) 6141 if !ok { 6142 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6143 } 6144 6145 if response.StatusCode < 200 || response.StatusCode >= 300 { 6146 return out, metadata, awsRestxml_deserializeOpErrorGetObjectTorrent(response, &metadata) 6147 } 6148 output := &GetObjectTorrentOutput{} 6149 out.Result = output 6150 6151 err = awsRestxml_deserializeOpHttpBindingsGetObjectTorrentOutput(output, response) 6152 if err != nil { 6153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 6154 } 6155 6156 err = awsRestxml_deserializeOpDocumentGetObjectTorrentOutput(output, response.Body) 6157 if err != nil { 6158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)} 6159 } 6160 6161 return out, metadata, err 6162} 6163 6164func awsRestxml_deserializeOpErrorGetObjectTorrent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6165 var errorBuffer bytes.Buffer 6166 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6167 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6168 } 6169 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6170 6171 errorCode := "UnknownError" 6172 errorMessage := errorCode 6173 6174 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6175 UseStatusCode: true, StatusCode: response.StatusCode, 6176 }) 6177 if err != nil { 6178 return err 6179 } 6180 if hostID := errorComponents.HostID; len(hostID) != 0 { 6181 s3shared.SetHostIDMetadata(metadata, hostID) 6182 } 6183 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6184 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6185 } 6186 if len(errorComponents.Code) != 0 { 6187 errorCode = errorComponents.Code 6188 } 6189 if len(errorComponents.Message) != 0 { 6190 errorMessage = errorComponents.Message 6191 } 6192 errorBody.Seek(0, io.SeekStart) 6193 switch { 6194 default: 6195 genericError := &smithy.GenericAPIError{ 6196 Code: errorCode, 6197 Message: errorMessage, 6198 } 6199 return genericError 6200 6201 } 6202} 6203 6204func awsRestxml_deserializeOpHttpBindingsGetObjectTorrentOutput(v *GetObjectTorrentOutput, response *smithyhttp.Response) error { 6205 if v == nil { 6206 return fmt.Errorf("unsupported deserialization for nil %T", v) 6207 } 6208 6209 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 6210 headerValues[0] = strings.TrimSpace(headerValues[0]) 6211 v.RequestCharged = types.RequestCharged(headerValues[0]) 6212 } 6213 6214 return nil 6215} 6216func awsRestxml_deserializeOpDocumentGetObjectTorrentOutput(v *GetObjectTorrentOutput, body io.ReadCloser) error { 6217 if v == nil { 6218 return fmt.Errorf("unsupported deserialization of nil %T", v) 6219 } 6220 v.Body = body 6221 return nil 6222} 6223 6224type awsRestxml_deserializeOpGetPublicAccessBlock struct { 6225} 6226 6227func (*awsRestxml_deserializeOpGetPublicAccessBlock) ID() string { 6228 return "OperationDeserializer" 6229} 6230 6231func (m *awsRestxml_deserializeOpGetPublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6232 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6233) { 6234 out, metadata, err = next.HandleDeserialize(ctx, in) 6235 if err != nil { 6236 return out, metadata, err 6237 } 6238 6239 response, ok := out.RawResponse.(*smithyhttp.Response) 6240 if !ok { 6241 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6242 } 6243 6244 if response.StatusCode < 200 || response.StatusCode >= 300 { 6245 return out, metadata, awsRestxml_deserializeOpErrorGetPublicAccessBlock(response, &metadata) 6246 } 6247 output := &GetPublicAccessBlockOutput{} 6248 out.Result = output 6249 6250 var buff [1024]byte 6251 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6252 body := io.TeeReader(response.Body, ringBuffer) 6253 rootDecoder := xml.NewDecoder(body) 6254 t, err := smithyxml.FetchRootElement(rootDecoder) 6255 if err == io.EOF { 6256 return out, metadata, nil 6257 } 6258 if err != nil { 6259 var snapshot bytes.Buffer 6260 io.Copy(&snapshot, ringBuffer) 6261 return out, metadata, &smithy.DeserializationError{ 6262 Err: fmt.Errorf("failed to decode response body, %w", err), 6263 Snapshot: snapshot.Bytes(), 6264 } 6265 } 6266 6267 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6268 err = awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&output.PublicAccessBlockConfiguration, decoder) 6269 if err != nil { 6270 var snapshot bytes.Buffer 6271 io.Copy(&snapshot, ringBuffer) 6272 return out, metadata, &smithy.DeserializationError{ 6273 Err: fmt.Errorf("failed to decode response body, %w", err), 6274 Snapshot: snapshot.Bytes(), 6275 } 6276 } 6277 6278 return out, metadata, err 6279} 6280 6281func awsRestxml_deserializeOpErrorGetPublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6282 var errorBuffer bytes.Buffer 6283 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6284 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6285 } 6286 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6287 6288 errorCode := "UnknownError" 6289 errorMessage := errorCode 6290 6291 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6292 UseStatusCode: true, StatusCode: response.StatusCode, 6293 }) 6294 if err != nil { 6295 return err 6296 } 6297 if hostID := errorComponents.HostID; len(hostID) != 0 { 6298 s3shared.SetHostIDMetadata(metadata, hostID) 6299 } 6300 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6301 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6302 } 6303 if len(errorComponents.Code) != 0 { 6304 errorCode = errorComponents.Code 6305 } 6306 if len(errorComponents.Message) != 0 { 6307 errorMessage = errorComponents.Message 6308 } 6309 errorBody.Seek(0, io.SeekStart) 6310 switch { 6311 default: 6312 genericError := &smithy.GenericAPIError{ 6313 Code: errorCode, 6314 Message: errorMessage, 6315 } 6316 return genericError 6317 6318 } 6319} 6320 6321func awsRestxml_deserializeOpDocumentGetPublicAccessBlockOutput(v **GetPublicAccessBlockOutput, decoder smithyxml.NodeDecoder) error { 6322 if v == nil { 6323 return fmt.Errorf("unexpected nil of type %T", v) 6324 } 6325 var sv *GetPublicAccessBlockOutput 6326 if *v == nil { 6327 sv = &GetPublicAccessBlockOutput{} 6328 } else { 6329 sv = *v 6330 } 6331 6332 for { 6333 t, done, err := decoder.Token() 6334 if err != nil { 6335 return err 6336 } 6337 if done { 6338 break 6339 } 6340 originalDecoder := decoder 6341 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6342 switch { 6343 case strings.EqualFold("PublicAccessBlockConfiguration", t.Name.Local): 6344 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6345 if err := awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(&sv.PublicAccessBlockConfiguration, nodeDecoder); err != nil { 6346 return err 6347 } 6348 6349 default: 6350 // Do nothing and ignore the unexpected tag element 6351 err = decoder.Decoder.Skip() 6352 if err != nil { 6353 return err 6354 } 6355 6356 } 6357 decoder = originalDecoder 6358 } 6359 *v = sv 6360 return nil 6361} 6362 6363type awsRestxml_deserializeOpHeadBucket struct { 6364} 6365 6366func (*awsRestxml_deserializeOpHeadBucket) ID() string { 6367 return "OperationDeserializer" 6368} 6369 6370func (m *awsRestxml_deserializeOpHeadBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6371 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6372) { 6373 out, metadata, err = next.HandleDeserialize(ctx, in) 6374 if err != nil { 6375 return out, metadata, err 6376 } 6377 6378 response, ok := out.RawResponse.(*smithyhttp.Response) 6379 if !ok { 6380 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6381 } 6382 6383 if response.StatusCode < 200 || response.StatusCode >= 300 { 6384 return out, metadata, awsRestxml_deserializeOpErrorHeadBucket(response, &metadata) 6385 } 6386 output := &HeadBucketOutput{} 6387 out.Result = output 6388 6389 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6390 return out, metadata, &smithy.DeserializationError{ 6391 Err: fmt.Errorf("failed to discard response body, %w", err), 6392 } 6393 } 6394 6395 return out, metadata, err 6396} 6397 6398func awsRestxml_deserializeOpErrorHeadBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6399 var errorBuffer bytes.Buffer 6400 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6401 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6402 } 6403 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6404 6405 errorCode := "UnknownError" 6406 errorMessage := errorCode 6407 6408 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6409 UseStatusCode: true, StatusCode: response.StatusCode, 6410 }) 6411 if err != nil { 6412 return err 6413 } 6414 if hostID := errorComponents.HostID; len(hostID) != 0 { 6415 s3shared.SetHostIDMetadata(metadata, hostID) 6416 } 6417 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6418 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6419 } 6420 if len(errorComponents.Code) != 0 { 6421 errorCode = errorComponents.Code 6422 } 6423 if len(errorComponents.Message) != 0 { 6424 errorMessage = errorComponents.Message 6425 } 6426 errorBody.Seek(0, io.SeekStart) 6427 switch { 6428 case strings.EqualFold("NotFound", errorCode): 6429 return awsRestxml_deserializeErrorNotFound(response, errorBody) 6430 6431 default: 6432 genericError := &smithy.GenericAPIError{ 6433 Code: errorCode, 6434 Message: errorMessage, 6435 } 6436 return genericError 6437 6438 } 6439} 6440 6441type awsRestxml_deserializeOpHeadObject struct { 6442} 6443 6444func (*awsRestxml_deserializeOpHeadObject) ID() string { 6445 return "OperationDeserializer" 6446} 6447 6448func (m *awsRestxml_deserializeOpHeadObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6449 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6450) { 6451 out, metadata, err = next.HandleDeserialize(ctx, in) 6452 if err != nil { 6453 return out, metadata, err 6454 } 6455 6456 response, ok := out.RawResponse.(*smithyhttp.Response) 6457 if !ok { 6458 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6459 } 6460 6461 if response.StatusCode < 200 || response.StatusCode >= 300 { 6462 return out, metadata, awsRestxml_deserializeOpErrorHeadObject(response, &metadata) 6463 } 6464 output := &HeadObjectOutput{} 6465 out.Result = output 6466 6467 err = awsRestxml_deserializeOpHttpBindingsHeadObjectOutput(output, response) 6468 if err != nil { 6469 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 6470 } 6471 6472 return out, metadata, err 6473} 6474 6475func awsRestxml_deserializeOpErrorHeadObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6476 var errorBuffer bytes.Buffer 6477 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6478 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6479 } 6480 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6481 6482 errorCode := "UnknownError" 6483 errorMessage := errorCode 6484 6485 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6486 UseStatusCode: true, StatusCode: response.StatusCode, 6487 }) 6488 if err != nil { 6489 return err 6490 } 6491 if hostID := errorComponents.HostID; len(hostID) != 0 { 6492 s3shared.SetHostIDMetadata(metadata, hostID) 6493 } 6494 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6495 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6496 } 6497 if len(errorComponents.Code) != 0 { 6498 errorCode = errorComponents.Code 6499 } 6500 if len(errorComponents.Message) != 0 { 6501 errorMessage = errorComponents.Message 6502 } 6503 errorBody.Seek(0, io.SeekStart) 6504 switch { 6505 default: 6506 genericError := &smithy.GenericAPIError{ 6507 Code: errorCode, 6508 Message: errorMessage, 6509 } 6510 return genericError 6511 6512 } 6513} 6514 6515func awsRestxml_deserializeOpHttpBindingsHeadObjectOutput(v *HeadObjectOutput, response *smithyhttp.Response) error { 6516 if v == nil { 6517 return fmt.Errorf("unsupported deserialization for nil %T", v) 6518 } 6519 6520 if headerValues := response.Header.Values("accept-ranges"); len(headerValues) != 0 { 6521 headerValues[0] = strings.TrimSpace(headerValues[0]) 6522 v.AcceptRanges = ptr.String(headerValues[0]) 6523 } 6524 6525 if headerValues := response.Header.Values("x-amz-archive-status"); len(headerValues) != 0 { 6526 headerValues[0] = strings.TrimSpace(headerValues[0]) 6527 v.ArchiveStatus = types.ArchiveStatus(headerValues[0]) 6528 } 6529 6530 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 6531 headerValues[0] = strings.TrimSpace(headerValues[0]) 6532 vv, err := strconv.ParseBool(headerValues[0]) 6533 if err != nil { 6534 return err 6535 } 6536 v.BucketKeyEnabled = vv 6537 } 6538 6539 if headerValues := response.Header.Values("Cache-Control"); len(headerValues) != 0 { 6540 headerValues[0] = strings.TrimSpace(headerValues[0]) 6541 v.CacheControl = ptr.String(headerValues[0]) 6542 } 6543 6544 if headerValues := response.Header.Values("Content-Disposition"); len(headerValues) != 0 { 6545 headerValues[0] = strings.TrimSpace(headerValues[0]) 6546 v.ContentDisposition = ptr.String(headerValues[0]) 6547 } 6548 6549 if headerValues := response.Header.Values("Content-Encoding"); len(headerValues) != 0 { 6550 headerValues[0] = strings.TrimSpace(headerValues[0]) 6551 v.ContentEncoding = ptr.String(headerValues[0]) 6552 } 6553 6554 if headerValues := response.Header.Values("Content-Language"); len(headerValues) != 0 { 6555 headerValues[0] = strings.TrimSpace(headerValues[0]) 6556 v.ContentLanguage = ptr.String(headerValues[0]) 6557 } 6558 6559 if headerValues := response.Header.Values("Content-Length"); len(headerValues) != 0 { 6560 headerValues[0] = strings.TrimSpace(headerValues[0]) 6561 vv, err := strconv.ParseInt(headerValues[0], 0, 64) 6562 if err != nil { 6563 return err 6564 } 6565 v.ContentLength = vv 6566 } 6567 6568 if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 { 6569 headerValues[0] = strings.TrimSpace(headerValues[0]) 6570 v.ContentType = ptr.String(headerValues[0]) 6571 } 6572 6573 if headerValues := response.Header.Values("x-amz-delete-marker"); len(headerValues) != 0 { 6574 headerValues[0] = strings.TrimSpace(headerValues[0]) 6575 vv, err := strconv.ParseBool(headerValues[0]) 6576 if err != nil { 6577 return err 6578 } 6579 v.DeleteMarker = vv 6580 } 6581 6582 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 6583 headerValues[0] = strings.TrimSpace(headerValues[0]) 6584 v.ETag = ptr.String(headerValues[0]) 6585 } 6586 6587 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 6588 headerValues[0] = strings.TrimSpace(headerValues[0]) 6589 v.Expiration = ptr.String(headerValues[0]) 6590 } 6591 6592 if headerValues := response.Header.Values("Expires"); len(headerValues) != 0 { 6593 headerValues[0] = strings.TrimSpace(headerValues[0]) 6594 t, err := smithytime.ParseHTTPDate(headerValues[0]) 6595 if err != nil { 6596 return err 6597 } 6598 v.Expires = ptr.Time(t) 6599 } 6600 6601 if headerValues := response.Header.Values("Last-Modified"); len(headerValues) != 0 { 6602 headerValues[0] = strings.TrimSpace(headerValues[0]) 6603 t, err := smithytime.ParseHTTPDate(headerValues[0]) 6604 if err != nil { 6605 return err 6606 } 6607 v.LastModified = ptr.Time(t) 6608 } 6609 6610 for headerKey, headerValues := range response.Header { 6611 if lenPrefix := len("x-amz-meta-"); len(headerKey) >= lenPrefix && strings.EqualFold(headerKey[:lenPrefix], "x-amz-meta-") { 6612 if v.Metadata == nil { 6613 v.Metadata = map[string]string{} 6614 } 6615 headerValues[0] = strings.TrimSpace(headerValues[0]) 6616 v.Metadata[strings.ToLower(headerKey[lenPrefix:])] = headerValues[0] 6617 } 6618 } 6619 6620 if headerValues := response.Header.Values("x-amz-missing-meta"); len(headerValues) != 0 { 6621 headerValues[0] = strings.TrimSpace(headerValues[0]) 6622 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 6623 if err != nil { 6624 return err 6625 } 6626 v.MissingMeta = int32(vv) 6627 } 6628 6629 if headerValues := response.Header.Values("x-amz-object-lock-legal-hold"); len(headerValues) != 0 { 6630 headerValues[0] = strings.TrimSpace(headerValues[0]) 6631 v.ObjectLockLegalHoldStatus = types.ObjectLockLegalHoldStatus(headerValues[0]) 6632 } 6633 6634 if headerValues := response.Header.Values("x-amz-object-lock-mode"); len(headerValues) != 0 { 6635 headerValues[0] = strings.TrimSpace(headerValues[0]) 6636 v.ObjectLockMode = types.ObjectLockMode(headerValues[0]) 6637 } 6638 6639 if headerValues := response.Header.Values("x-amz-object-lock-retain-until-date"); len(headerValues) != 0 { 6640 headerValues[0] = strings.TrimSpace(headerValues[0]) 6641 t, err := smithytime.ParseDateTime(headerValues[0]) 6642 if err != nil { 6643 return err 6644 } 6645 v.ObjectLockRetainUntilDate = ptr.Time(t) 6646 } 6647 6648 if headerValues := response.Header.Values("x-amz-mp-parts-count"); len(headerValues) != 0 { 6649 headerValues[0] = strings.TrimSpace(headerValues[0]) 6650 vv, err := strconv.ParseInt(headerValues[0], 0, 32) 6651 if err != nil { 6652 return err 6653 } 6654 v.PartsCount = int32(vv) 6655 } 6656 6657 if headerValues := response.Header.Values("x-amz-replication-status"); len(headerValues) != 0 { 6658 headerValues[0] = strings.TrimSpace(headerValues[0]) 6659 v.ReplicationStatus = types.ReplicationStatus(headerValues[0]) 6660 } 6661 6662 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 6663 headerValues[0] = strings.TrimSpace(headerValues[0]) 6664 v.RequestCharged = types.RequestCharged(headerValues[0]) 6665 } 6666 6667 if headerValues := response.Header.Values("x-amz-restore"); len(headerValues) != 0 { 6668 headerValues[0] = strings.TrimSpace(headerValues[0]) 6669 v.Restore = ptr.String(headerValues[0]) 6670 } 6671 6672 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 6673 headerValues[0] = strings.TrimSpace(headerValues[0]) 6674 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 6675 } 6676 6677 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 6678 headerValues[0] = strings.TrimSpace(headerValues[0]) 6679 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 6680 } 6681 6682 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 6683 headerValues[0] = strings.TrimSpace(headerValues[0]) 6684 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 6685 } 6686 6687 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 6688 headerValues[0] = strings.TrimSpace(headerValues[0]) 6689 v.SSEKMSKeyId = ptr.String(headerValues[0]) 6690 } 6691 6692 if headerValues := response.Header.Values("x-amz-storage-class"); len(headerValues) != 0 { 6693 headerValues[0] = strings.TrimSpace(headerValues[0]) 6694 v.StorageClass = types.StorageClass(headerValues[0]) 6695 } 6696 6697 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 6698 headerValues[0] = strings.TrimSpace(headerValues[0]) 6699 v.VersionId = ptr.String(headerValues[0]) 6700 } 6701 6702 if headerValues := response.Header.Values("x-amz-website-redirect-location"); len(headerValues) != 0 { 6703 headerValues[0] = strings.TrimSpace(headerValues[0]) 6704 v.WebsiteRedirectLocation = ptr.String(headerValues[0]) 6705 } 6706 6707 return nil 6708} 6709 6710type awsRestxml_deserializeOpListBucketAnalyticsConfigurations struct { 6711} 6712 6713func (*awsRestxml_deserializeOpListBucketAnalyticsConfigurations) ID() string { 6714 return "OperationDeserializer" 6715} 6716 6717func (m *awsRestxml_deserializeOpListBucketAnalyticsConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6718 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6719) { 6720 out, metadata, err = next.HandleDeserialize(ctx, in) 6721 if err != nil { 6722 return out, metadata, err 6723 } 6724 6725 response, ok := out.RawResponse.(*smithyhttp.Response) 6726 if !ok { 6727 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6728 } 6729 6730 if response.StatusCode < 200 || response.StatusCode >= 300 { 6731 return out, metadata, awsRestxml_deserializeOpErrorListBucketAnalyticsConfigurations(response, &metadata) 6732 } 6733 output := &ListBucketAnalyticsConfigurationsOutput{} 6734 out.Result = output 6735 6736 var buff [1024]byte 6737 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6738 body := io.TeeReader(response.Body, ringBuffer) 6739 rootDecoder := xml.NewDecoder(body) 6740 t, err := smithyxml.FetchRootElement(rootDecoder) 6741 if err == io.EOF { 6742 return out, metadata, nil 6743 } 6744 if err != nil { 6745 var snapshot bytes.Buffer 6746 io.Copy(&snapshot, ringBuffer) 6747 return out, metadata, &smithy.DeserializationError{ 6748 Err: fmt.Errorf("failed to decode response body, %w", err), 6749 Snapshot: snapshot.Bytes(), 6750 } 6751 } 6752 6753 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6754 err = awsRestxml_deserializeOpDocumentListBucketAnalyticsConfigurationsOutput(&output, decoder) 6755 if err != nil { 6756 var snapshot bytes.Buffer 6757 io.Copy(&snapshot, ringBuffer) 6758 return out, metadata, &smithy.DeserializationError{ 6759 Err: fmt.Errorf("failed to decode response body, %w", err), 6760 Snapshot: snapshot.Bytes(), 6761 } 6762 } 6763 6764 return out, metadata, err 6765} 6766 6767func awsRestxml_deserializeOpErrorListBucketAnalyticsConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6768 var errorBuffer bytes.Buffer 6769 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6770 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6771 } 6772 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6773 6774 errorCode := "UnknownError" 6775 errorMessage := errorCode 6776 6777 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6778 UseStatusCode: true, StatusCode: response.StatusCode, 6779 }) 6780 if err != nil { 6781 return err 6782 } 6783 if hostID := errorComponents.HostID; len(hostID) != 0 { 6784 s3shared.SetHostIDMetadata(metadata, hostID) 6785 } 6786 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6787 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6788 } 6789 if len(errorComponents.Code) != 0 { 6790 errorCode = errorComponents.Code 6791 } 6792 if len(errorComponents.Message) != 0 { 6793 errorMessage = errorComponents.Message 6794 } 6795 errorBody.Seek(0, io.SeekStart) 6796 switch { 6797 default: 6798 genericError := &smithy.GenericAPIError{ 6799 Code: errorCode, 6800 Message: errorMessage, 6801 } 6802 return genericError 6803 6804 } 6805} 6806 6807func awsRestxml_deserializeOpDocumentListBucketAnalyticsConfigurationsOutput(v **ListBucketAnalyticsConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 6808 if v == nil { 6809 return fmt.Errorf("unexpected nil of type %T", v) 6810 } 6811 var sv *ListBucketAnalyticsConfigurationsOutput 6812 if *v == nil { 6813 sv = &ListBucketAnalyticsConfigurationsOutput{} 6814 } else { 6815 sv = *v 6816 } 6817 6818 for { 6819 t, done, err := decoder.Token() 6820 if err != nil { 6821 return err 6822 } 6823 if done { 6824 break 6825 } 6826 originalDecoder := decoder 6827 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 6828 switch { 6829 case strings.EqualFold("AnalyticsConfiguration", t.Name.Local): 6830 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 6831 if err := awsRestxml_deserializeDocumentAnalyticsConfigurationListUnwrapped(&sv.AnalyticsConfigurationList, nodeDecoder); err != nil { 6832 return err 6833 } 6834 6835 case strings.EqualFold("ContinuationToken", t.Name.Local): 6836 val, err := decoder.Value() 6837 if err != nil { 6838 return err 6839 } 6840 if val == nil { 6841 break 6842 } 6843 { 6844 xtv := string(val) 6845 sv.ContinuationToken = ptr.String(xtv) 6846 } 6847 6848 case strings.EqualFold("IsTruncated", t.Name.Local): 6849 val, err := decoder.Value() 6850 if err != nil { 6851 return err 6852 } 6853 if val == nil { 6854 break 6855 } 6856 { 6857 xtv, err := strconv.ParseBool(string(val)) 6858 if err != nil { 6859 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 6860 } 6861 sv.IsTruncated = xtv 6862 } 6863 6864 case strings.EqualFold("NextContinuationToken", t.Name.Local): 6865 val, err := decoder.Value() 6866 if err != nil { 6867 return err 6868 } 6869 if val == nil { 6870 break 6871 } 6872 { 6873 xtv := string(val) 6874 sv.NextContinuationToken = ptr.String(xtv) 6875 } 6876 6877 default: 6878 // Do nothing and ignore the unexpected tag element 6879 err = decoder.Decoder.Skip() 6880 if err != nil { 6881 return err 6882 } 6883 6884 } 6885 decoder = originalDecoder 6886 } 6887 *v = sv 6888 return nil 6889} 6890 6891type awsRestxml_deserializeOpListBucketIntelligentTieringConfigurations struct { 6892} 6893 6894func (*awsRestxml_deserializeOpListBucketIntelligentTieringConfigurations) ID() string { 6895 return "OperationDeserializer" 6896} 6897 6898func (m *awsRestxml_deserializeOpListBucketIntelligentTieringConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6899 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6900) { 6901 out, metadata, err = next.HandleDeserialize(ctx, in) 6902 if err != nil { 6903 return out, metadata, err 6904 } 6905 6906 response, ok := out.RawResponse.(*smithyhttp.Response) 6907 if !ok { 6908 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6909 } 6910 6911 if response.StatusCode < 200 || response.StatusCode >= 300 { 6912 return out, metadata, awsRestxml_deserializeOpErrorListBucketIntelligentTieringConfigurations(response, &metadata) 6913 } 6914 output := &ListBucketIntelligentTieringConfigurationsOutput{} 6915 out.Result = output 6916 6917 var buff [1024]byte 6918 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6919 body := io.TeeReader(response.Body, ringBuffer) 6920 rootDecoder := xml.NewDecoder(body) 6921 t, err := smithyxml.FetchRootElement(rootDecoder) 6922 if err == io.EOF { 6923 return out, metadata, nil 6924 } 6925 if err != nil { 6926 var snapshot bytes.Buffer 6927 io.Copy(&snapshot, ringBuffer) 6928 return out, metadata, &smithy.DeserializationError{ 6929 Err: fmt.Errorf("failed to decode response body, %w", err), 6930 Snapshot: snapshot.Bytes(), 6931 } 6932 } 6933 6934 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 6935 err = awsRestxml_deserializeOpDocumentListBucketIntelligentTieringConfigurationsOutput(&output, decoder) 6936 if err != nil { 6937 var snapshot bytes.Buffer 6938 io.Copy(&snapshot, ringBuffer) 6939 return out, metadata, &smithy.DeserializationError{ 6940 Err: fmt.Errorf("failed to decode response body, %w", err), 6941 Snapshot: snapshot.Bytes(), 6942 } 6943 } 6944 6945 return out, metadata, err 6946} 6947 6948func awsRestxml_deserializeOpErrorListBucketIntelligentTieringConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6949 var errorBuffer bytes.Buffer 6950 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6951 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6952 } 6953 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6954 6955 errorCode := "UnknownError" 6956 errorMessage := errorCode 6957 6958 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 6959 UseStatusCode: true, StatusCode: response.StatusCode, 6960 }) 6961 if err != nil { 6962 return err 6963 } 6964 if hostID := errorComponents.HostID; len(hostID) != 0 { 6965 s3shared.SetHostIDMetadata(metadata, hostID) 6966 } 6967 if reqID := errorComponents.RequestID; len(reqID) != 0 { 6968 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 6969 } 6970 if len(errorComponents.Code) != 0 { 6971 errorCode = errorComponents.Code 6972 } 6973 if len(errorComponents.Message) != 0 { 6974 errorMessage = errorComponents.Message 6975 } 6976 errorBody.Seek(0, io.SeekStart) 6977 switch { 6978 default: 6979 genericError := &smithy.GenericAPIError{ 6980 Code: errorCode, 6981 Message: errorMessage, 6982 } 6983 return genericError 6984 6985 } 6986} 6987 6988func awsRestxml_deserializeOpDocumentListBucketIntelligentTieringConfigurationsOutput(v **ListBucketIntelligentTieringConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 6989 if v == nil { 6990 return fmt.Errorf("unexpected nil of type %T", v) 6991 } 6992 var sv *ListBucketIntelligentTieringConfigurationsOutput 6993 if *v == nil { 6994 sv = &ListBucketIntelligentTieringConfigurationsOutput{} 6995 } else { 6996 sv = *v 6997 } 6998 6999 for { 7000 t, done, err := decoder.Token() 7001 if err != nil { 7002 return err 7003 } 7004 if done { 7005 break 7006 } 7007 originalDecoder := decoder 7008 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7009 switch { 7010 case strings.EqualFold("ContinuationToken", t.Name.Local): 7011 val, err := decoder.Value() 7012 if err != nil { 7013 return err 7014 } 7015 if val == nil { 7016 break 7017 } 7018 { 7019 xtv := string(val) 7020 sv.ContinuationToken = ptr.String(xtv) 7021 } 7022 7023 case strings.EqualFold("IntelligentTieringConfiguration", t.Name.Local): 7024 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7025 if err := awsRestxml_deserializeDocumentIntelligentTieringConfigurationListUnwrapped(&sv.IntelligentTieringConfigurationList, nodeDecoder); err != nil { 7026 return err 7027 } 7028 7029 case strings.EqualFold("IsTruncated", t.Name.Local): 7030 val, err := decoder.Value() 7031 if err != nil { 7032 return err 7033 } 7034 if val == nil { 7035 break 7036 } 7037 { 7038 xtv, err := strconv.ParseBool(string(val)) 7039 if err != nil { 7040 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7041 } 7042 sv.IsTruncated = xtv 7043 } 7044 7045 case strings.EqualFold("NextContinuationToken", t.Name.Local): 7046 val, err := decoder.Value() 7047 if err != nil { 7048 return err 7049 } 7050 if val == nil { 7051 break 7052 } 7053 { 7054 xtv := string(val) 7055 sv.NextContinuationToken = ptr.String(xtv) 7056 } 7057 7058 default: 7059 // Do nothing and ignore the unexpected tag element 7060 err = decoder.Decoder.Skip() 7061 if err != nil { 7062 return err 7063 } 7064 7065 } 7066 decoder = originalDecoder 7067 } 7068 *v = sv 7069 return nil 7070} 7071 7072type awsRestxml_deserializeOpListBucketInventoryConfigurations struct { 7073} 7074 7075func (*awsRestxml_deserializeOpListBucketInventoryConfigurations) ID() string { 7076 return "OperationDeserializer" 7077} 7078 7079func (m *awsRestxml_deserializeOpListBucketInventoryConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7080 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7081) { 7082 out, metadata, err = next.HandleDeserialize(ctx, in) 7083 if err != nil { 7084 return out, metadata, err 7085 } 7086 7087 response, ok := out.RawResponse.(*smithyhttp.Response) 7088 if !ok { 7089 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7090 } 7091 7092 if response.StatusCode < 200 || response.StatusCode >= 300 { 7093 return out, metadata, awsRestxml_deserializeOpErrorListBucketInventoryConfigurations(response, &metadata) 7094 } 7095 output := &ListBucketInventoryConfigurationsOutput{} 7096 out.Result = output 7097 7098 var buff [1024]byte 7099 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7100 body := io.TeeReader(response.Body, ringBuffer) 7101 rootDecoder := xml.NewDecoder(body) 7102 t, err := smithyxml.FetchRootElement(rootDecoder) 7103 if err == io.EOF { 7104 return out, metadata, nil 7105 } 7106 if err != nil { 7107 var snapshot bytes.Buffer 7108 io.Copy(&snapshot, ringBuffer) 7109 return out, metadata, &smithy.DeserializationError{ 7110 Err: fmt.Errorf("failed to decode response body, %w", err), 7111 Snapshot: snapshot.Bytes(), 7112 } 7113 } 7114 7115 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7116 err = awsRestxml_deserializeOpDocumentListBucketInventoryConfigurationsOutput(&output, decoder) 7117 if err != nil { 7118 var snapshot bytes.Buffer 7119 io.Copy(&snapshot, ringBuffer) 7120 return out, metadata, &smithy.DeserializationError{ 7121 Err: fmt.Errorf("failed to decode response body, %w", err), 7122 Snapshot: snapshot.Bytes(), 7123 } 7124 } 7125 7126 return out, metadata, err 7127} 7128 7129func awsRestxml_deserializeOpErrorListBucketInventoryConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7130 var errorBuffer bytes.Buffer 7131 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7132 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7133 } 7134 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7135 7136 errorCode := "UnknownError" 7137 errorMessage := errorCode 7138 7139 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7140 UseStatusCode: true, StatusCode: response.StatusCode, 7141 }) 7142 if err != nil { 7143 return err 7144 } 7145 if hostID := errorComponents.HostID; len(hostID) != 0 { 7146 s3shared.SetHostIDMetadata(metadata, hostID) 7147 } 7148 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7149 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7150 } 7151 if len(errorComponents.Code) != 0 { 7152 errorCode = errorComponents.Code 7153 } 7154 if len(errorComponents.Message) != 0 { 7155 errorMessage = errorComponents.Message 7156 } 7157 errorBody.Seek(0, io.SeekStart) 7158 switch { 7159 default: 7160 genericError := &smithy.GenericAPIError{ 7161 Code: errorCode, 7162 Message: errorMessage, 7163 } 7164 return genericError 7165 7166 } 7167} 7168 7169func awsRestxml_deserializeOpDocumentListBucketInventoryConfigurationsOutput(v **ListBucketInventoryConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 7170 if v == nil { 7171 return fmt.Errorf("unexpected nil of type %T", v) 7172 } 7173 var sv *ListBucketInventoryConfigurationsOutput 7174 if *v == nil { 7175 sv = &ListBucketInventoryConfigurationsOutput{} 7176 } else { 7177 sv = *v 7178 } 7179 7180 for { 7181 t, done, err := decoder.Token() 7182 if err != nil { 7183 return err 7184 } 7185 if done { 7186 break 7187 } 7188 originalDecoder := decoder 7189 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7190 switch { 7191 case strings.EqualFold("ContinuationToken", t.Name.Local): 7192 val, err := decoder.Value() 7193 if err != nil { 7194 return err 7195 } 7196 if val == nil { 7197 break 7198 } 7199 { 7200 xtv := string(val) 7201 sv.ContinuationToken = ptr.String(xtv) 7202 } 7203 7204 case strings.EqualFold("InventoryConfiguration", t.Name.Local): 7205 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7206 if err := awsRestxml_deserializeDocumentInventoryConfigurationListUnwrapped(&sv.InventoryConfigurationList, nodeDecoder); err != nil { 7207 return err 7208 } 7209 7210 case strings.EqualFold("IsTruncated", t.Name.Local): 7211 val, err := decoder.Value() 7212 if err != nil { 7213 return err 7214 } 7215 if val == nil { 7216 break 7217 } 7218 { 7219 xtv, err := strconv.ParseBool(string(val)) 7220 if err != nil { 7221 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7222 } 7223 sv.IsTruncated = xtv 7224 } 7225 7226 case strings.EqualFold("NextContinuationToken", t.Name.Local): 7227 val, err := decoder.Value() 7228 if err != nil { 7229 return err 7230 } 7231 if val == nil { 7232 break 7233 } 7234 { 7235 xtv := string(val) 7236 sv.NextContinuationToken = ptr.String(xtv) 7237 } 7238 7239 default: 7240 // Do nothing and ignore the unexpected tag element 7241 err = decoder.Decoder.Skip() 7242 if err != nil { 7243 return err 7244 } 7245 7246 } 7247 decoder = originalDecoder 7248 } 7249 *v = sv 7250 return nil 7251} 7252 7253type awsRestxml_deserializeOpListBucketMetricsConfigurations struct { 7254} 7255 7256func (*awsRestxml_deserializeOpListBucketMetricsConfigurations) ID() string { 7257 return "OperationDeserializer" 7258} 7259 7260func (m *awsRestxml_deserializeOpListBucketMetricsConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7262) { 7263 out, metadata, err = next.HandleDeserialize(ctx, in) 7264 if err != nil { 7265 return out, metadata, err 7266 } 7267 7268 response, ok := out.RawResponse.(*smithyhttp.Response) 7269 if !ok { 7270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7271 } 7272 7273 if response.StatusCode < 200 || response.StatusCode >= 300 { 7274 return out, metadata, awsRestxml_deserializeOpErrorListBucketMetricsConfigurations(response, &metadata) 7275 } 7276 output := &ListBucketMetricsConfigurationsOutput{} 7277 out.Result = output 7278 7279 var buff [1024]byte 7280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7281 body := io.TeeReader(response.Body, ringBuffer) 7282 rootDecoder := xml.NewDecoder(body) 7283 t, err := smithyxml.FetchRootElement(rootDecoder) 7284 if err == io.EOF { 7285 return out, metadata, nil 7286 } 7287 if err != nil { 7288 var snapshot bytes.Buffer 7289 io.Copy(&snapshot, ringBuffer) 7290 return out, metadata, &smithy.DeserializationError{ 7291 Err: fmt.Errorf("failed to decode response body, %w", err), 7292 Snapshot: snapshot.Bytes(), 7293 } 7294 } 7295 7296 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7297 err = awsRestxml_deserializeOpDocumentListBucketMetricsConfigurationsOutput(&output, decoder) 7298 if err != nil { 7299 var snapshot bytes.Buffer 7300 io.Copy(&snapshot, ringBuffer) 7301 return out, metadata, &smithy.DeserializationError{ 7302 Err: fmt.Errorf("failed to decode response body, %w", err), 7303 Snapshot: snapshot.Bytes(), 7304 } 7305 } 7306 7307 return out, metadata, err 7308} 7309 7310func awsRestxml_deserializeOpErrorListBucketMetricsConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7311 var errorBuffer bytes.Buffer 7312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7314 } 7315 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7316 7317 errorCode := "UnknownError" 7318 errorMessage := errorCode 7319 7320 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7321 UseStatusCode: true, StatusCode: response.StatusCode, 7322 }) 7323 if err != nil { 7324 return err 7325 } 7326 if hostID := errorComponents.HostID; len(hostID) != 0 { 7327 s3shared.SetHostIDMetadata(metadata, hostID) 7328 } 7329 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7330 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7331 } 7332 if len(errorComponents.Code) != 0 { 7333 errorCode = errorComponents.Code 7334 } 7335 if len(errorComponents.Message) != 0 { 7336 errorMessage = errorComponents.Message 7337 } 7338 errorBody.Seek(0, io.SeekStart) 7339 switch { 7340 default: 7341 genericError := &smithy.GenericAPIError{ 7342 Code: errorCode, 7343 Message: errorMessage, 7344 } 7345 return genericError 7346 7347 } 7348} 7349 7350func awsRestxml_deserializeOpDocumentListBucketMetricsConfigurationsOutput(v **ListBucketMetricsConfigurationsOutput, decoder smithyxml.NodeDecoder) error { 7351 if v == nil { 7352 return fmt.Errorf("unexpected nil of type %T", v) 7353 } 7354 var sv *ListBucketMetricsConfigurationsOutput 7355 if *v == nil { 7356 sv = &ListBucketMetricsConfigurationsOutput{} 7357 } else { 7358 sv = *v 7359 } 7360 7361 for { 7362 t, done, err := decoder.Token() 7363 if err != nil { 7364 return err 7365 } 7366 if done { 7367 break 7368 } 7369 originalDecoder := decoder 7370 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7371 switch { 7372 case strings.EqualFold("ContinuationToken", t.Name.Local): 7373 val, err := decoder.Value() 7374 if err != nil { 7375 return err 7376 } 7377 if val == nil { 7378 break 7379 } 7380 { 7381 xtv := string(val) 7382 sv.ContinuationToken = ptr.String(xtv) 7383 } 7384 7385 case strings.EqualFold("IsTruncated", t.Name.Local): 7386 val, err := decoder.Value() 7387 if err != nil { 7388 return err 7389 } 7390 if val == nil { 7391 break 7392 } 7393 { 7394 xtv, err := strconv.ParseBool(string(val)) 7395 if err != nil { 7396 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7397 } 7398 sv.IsTruncated = xtv 7399 } 7400 7401 case strings.EqualFold("MetricsConfiguration", t.Name.Local): 7402 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7403 if err := awsRestxml_deserializeDocumentMetricsConfigurationListUnwrapped(&sv.MetricsConfigurationList, nodeDecoder); err != nil { 7404 return err 7405 } 7406 7407 case strings.EqualFold("NextContinuationToken", t.Name.Local): 7408 val, err := decoder.Value() 7409 if err != nil { 7410 return err 7411 } 7412 if val == nil { 7413 break 7414 } 7415 { 7416 xtv := string(val) 7417 sv.NextContinuationToken = ptr.String(xtv) 7418 } 7419 7420 default: 7421 // Do nothing and ignore the unexpected tag element 7422 err = decoder.Decoder.Skip() 7423 if err != nil { 7424 return err 7425 } 7426 7427 } 7428 decoder = originalDecoder 7429 } 7430 *v = sv 7431 return nil 7432} 7433 7434type awsRestxml_deserializeOpListBuckets struct { 7435} 7436 7437func (*awsRestxml_deserializeOpListBuckets) ID() string { 7438 return "OperationDeserializer" 7439} 7440 7441func (m *awsRestxml_deserializeOpListBuckets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7442 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7443) { 7444 out, metadata, err = next.HandleDeserialize(ctx, in) 7445 if err != nil { 7446 return out, metadata, err 7447 } 7448 7449 response, ok := out.RawResponse.(*smithyhttp.Response) 7450 if !ok { 7451 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7452 } 7453 7454 if response.StatusCode < 200 || response.StatusCode >= 300 { 7455 return out, metadata, awsRestxml_deserializeOpErrorListBuckets(response, &metadata) 7456 } 7457 output := &ListBucketsOutput{} 7458 out.Result = output 7459 7460 var buff [1024]byte 7461 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7462 body := io.TeeReader(response.Body, ringBuffer) 7463 rootDecoder := xml.NewDecoder(body) 7464 t, err := smithyxml.FetchRootElement(rootDecoder) 7465 if err == io.EOF { 7466 return out, metadata, nil 7467 } 7468 if err != nil { 7469 var snapshot bytes.Buffer 7470 io.Copy(&snapshot, ringBuffer) 7471 return out, metadata, &smithy.DeserializationError{ 7472 Err: fmt.Errorf("failed to decode response body, %w", err), 7473 Snapshot: snapshot.Bytes(), 7474 } 7475 } 7476 7477 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7478 err = awsRestxml_deserializeOpDocumentListBucketsOutput(&output, decoder) 7479 if err != nil { 7480 var snapshot bytes.Buffer 7481 io.Copy(&snapshot, ringBuffer) 7482 return out, metadata, &smithy.DeserializationError{ 7483 Err: fmt.Errorf("failed to decode response body, %w", err), 7484 Snapshot: snapshot.Bytes(), 7485 } 7486 } 7487 7488 return out, metadata, err 7489} 7490 7491func awsRestxml_deserializeOpErrorListBuckets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7492 var errorBuffer bytes.Buffer 7493 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7494 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7495 } 7496 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7497 7498 errorCode := "UnknownError" 7499 errorMessage := errorCode 7500 7501 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7502 UseStatusCode: true, StatusCode: response.StatusCode, 7503 }) 7504 if err != nil { 7505 return err 7506 } 7507 if hostID := errorComponents.HostID; len(hostID) != 0 { 7508 s3shared.SetHostIDMetadata(metadata, hostID) 7509 } 7510 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7511 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7512 } 7513 if len(errorComponents.Code) != 0 { 7514 errorCode = errorComponents.Code 7515 } 7516 if len(errorComponents.Message) != 0 { 7517 errorMessage = errorComponents.Message 7518 } 7519 errorBody.Seek(0, io.SeekStart) 7520 switch { 7521 default: 7522 genericError := &smithy.GenericAPIError{ 7523 Code: errorCode, 7524 Message: errorMessage, 7525 } 7526 return genericError 7527 7528 } 7529} 7530 7531func awsRestxml_deserializeOpDocumentListBucketsOutput(v **ListBucketsOutput, decoder smithyxml.NodeDecoder) error { 7532 if v == nil { 7533 return fmt.Errorf("unexpected nil of type %T", v) 7534 } 7535 var sv *ListBucketsOutput 7536 if *v == nil { 7537 sv = &ListBucketsOutput{} 7538 } else { 7539 sv = *v 7540 } 7541 7542 for { 7543 t, done, err := decoder.Token() 7544 if err != nil { 7545 return err 7546 } 7547 if done { 7548 break 7549 } 7550 originalDecoder := decoder 7551 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7552 switch { 7553 case strings.EqualFold("Buckets", t.Name.Local): 7554 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7555 if err := awsRestxml_deserializeDocumentBuckets(&sv.Buckets, nodeDecoder); err != nil { 7556 return err 7557 } 7558 7559 case strings.EqualFold("Owner", t.Name.Local): 7560 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7561 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 7562 return err 7563 } 7564 7565 default: 7566 // Do nothing and ignore the unexpected tag element 7567 err = decoder.Decoder.Skip() 7568 if err != nil { 7569 return err 7570 } 7571 7572 } 7573 decoder = originalDecoder 7574 } 7575 *v = sv 7576 return nil 7577} 7578 7579type awsRestxml_deserializeOpListMultipartUploads struct { 7580} 7581 7582func (*awsRestxml_deserializeOpListMultipartUploads) ID() string { 7583 return "OperationDeserializer" 7584} 7585 7586func (m *awsRestxml_deserializeOpListMultipartUploads) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7587 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7588) { 7589 out, metadata, err = next.HandleDeserialize(ctx, in) 7590 if err != nil { 7591 return out, metadata, err 7592 } 7593 7594 response, ok := out.RawResponse.(*smithyhttp.Response) 7595 if !ok { 7596 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7597 } 7598 7599 if response.StatusCode < 200 || response.StatusCode >= 300 { 7600 return out, metadata, awsRestxml_deserializeOpErrorListMultipartUploads(response, &metadata) 7601 } 7602 output := &ListMultipartUploadsOutput{} 7603 out.Result = output 7604 7605 var buff [1024]byte 7606 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7607 body := io.TeeReader(response.Body, ringBuffer) 7608 rootDecoder := xml.NewDecoder(body) 7609 t, err := smithyxml.FetchRootElement(rootDecoder) 7610 if err == io.EOF { 7611 return out, metadata, nil 7612 } 7613 if err != nil { 7614 var snapshot bytes.Buffer 7615 io.Copy(&snapshot, ringBuffer) 7616 return out, metadata, &smithy.DeserializationError{ 7617 Err: fmt.Errorf("failed to decode response body, %w", err), 7618 Snapshot: snapshot.Bytes(), 7619 } 7620 } 7621 7622 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7623 err = awsRestxml_deserializeOpDocumentListMultipartUploadsOutput(&output, decoder) 7624 if err != nil { 7625 var snapshot bytes.Buffer 7626 io.Copy(&snapshot, ringBuffer) 7627 return out, metadata, &smithy.DeserializationError{ 7628 Err: fmt.Errorf("failed to decode response body, %w", err), 7629 Snapshot: snapshot.Bytes(), 7630 } 7631 } 7632 7633 return out, metadata, err 7634} 7635 7636func awsRestxml_deserializeOpErrorListMultipartUploads(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7637 var errorBuffer bytes.Buffer 7638 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7639 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7640 } 7641 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7642 7643 errorCode := "UnknownError" 7644 errorMessage := errorCode 7645 7646 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7647 UseStatusCode: true, StatusCode: response.StatusCode, 7648 }) 7649 if err != nil { 7650 return err 7651 } 7652 if hostID := errorComponents.HostID; len(hostID) != 0 { 7653 s3shared.SetHostIDMetadata(metadata, hostID) 7654 } 7655 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7656 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7657 } 7658 if len(errorComponents.Code) != 0 { 7659 errorCode = errorComponents.Code 7660 } 7661 if len(errorComponents.Message) != 0 { 7662 errorMessage = errorComponents.Message 7663 } 7664 errorBody.Seek(0, io.SeekStart) 7665 switch { 7666 default: 7667 genericError := &smithy.GenericAPIError{ 7668 Code: errorCode, 7669 Message: errorMessage, 7670 } 7671 return genericError 7672 7673 } 7674} 7675 7676func awsRestxml_deserializeOpDocumentListMultipartUploadsOutput(v **ListMultipartUploadsOutput, decoder smithyxml.NodeDecoder) error { 7677 if v == nil { 7678 return fmt.Errorf("unexpected nil of type %T", v) 7679 } 7680 var sv *ListMultipartUploadsOutput 7681 if *v == nil { 7682 sv = &ListMultipartUploadsOutput{} 7683 } else { 7684 sv = *v 7685 } 7686 7687 for { 7688 t, done, err := decoder.Token() 7689 if err != nil { 7690 return err 7691 } 7692 if done { 7693 break 7694 } 7695 originalDecoder := decoder 7696 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7697 switch { 7698 case strings.EqualFold("Bucket", t.Name.Local): 7699 val, err := decoder.Value() 7700 if err != nil { 7701 return err 7702 } 7703 if val == nil { 7704 break 7705 } 7706 { 7707 xtv := string(val) 7708 sv.Bucket = ptr.String(xtv) 7709 } 7710 7711 case strings.EqualFold("CommonPrefixes", t.Name.Local): 7712 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7713 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 7714 return err 7715 } 7716 7717 case strings.EqualFold("Delimiter", t.Name.Local): 7718 val, err := decoder.Value() 7719 if err != nil { 7720 return err 7721 } 7722 if val == nil { 7723 break 7724 } 7725 { 7726 xtv := string(val) 7727 sv.Delimiter = ptr.String(xtv) 7728 } 7729 7730 case strings.EqualFold("EncodingType", t.Name.Local): 7731 val, err := decoder.Value() 7732 if err != nil { 7733 return err 7734 } 7735 if val == nil { 7736 break 7737 } 7738 { 7739 xtv := string(val) 7740 sv.EncodingType = types.EncodingType(xtv) 7741 } 7742 7743 case strings.EqualFold("IsTruncated", t.Name.Local): 7744 val, err := decoder.Value() 7745 if err != nil { 7746 return err 7747 } 7748 if val == nil { 7749 break 7750 } 7751 { 7752 xtv, err := strconv.ParseBool(string(val)) 7753 if err != nil { 7754 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 7755 } 7756 sv.IsTruncated = xtv 7757 } 7758 7759 case strings.EqualFold("KeyMarker", t.Name.Local): 7760 val, err := decoder.Value() 7761 if err != nil { 7762 return err 7763 } 7764 if val == nil { 7765 break 7766 } 7767 { 7768 xtv := string(val) 7769 sv.KeyMarker = ptr.String(xtv) 7770 } 7771 7772 case strings.EqualFold("MaxUploads", t.Name.Local): 7773 val, err := decoder.Value() 7774 if err != nil { 7775 return err 7776 } 7777 if val == nil { 7778 break 7779 } 7780 { 7781 xtv := string(val) 7782 i64, err := strconv.ParseInt(xtv, 10, 64) 7783 if err != nil { 7784 return err 7785 } 7786 sv.MaxUploads = int32(i64) 7787 } 7788 7789 case strings.EqualFold("NextKeyMarker", t.Name.Local): 7790 val, err := decoder.Value() 7791 if err != nil { 7792 return err 7793 } 7794 if val == nil { 7795 break 7796 } 7797 { 7798 xtv := string(val) 7799 sv.NextKeyMarker = ptr.String(xtv) 7800 } 7801 7802 case strings.EqualFold("NextUploadIdMarker", t.Name.Local): 7803 val, err := decoder.Value() 7804 if err != nil { 7805 return err 7806 } 7807 if val == nil { 7808 break 7809 } 7810 { 7811 xtv := string(val) 7812 sv.NextUploadIdMarker = ptr.String(xtv) 7813 } 7814 7815 case strings.EqualFold("Prefix", t.Name.Local): 7816 val, err := decoder.Value() 7817 if err != nil { 7818 return err 7819 } 7820 if val == nil { 7821 break 7822 } 7823 { 7824 xtv := string(val) 7825 sv.Prefix = ptr.String(xtv) 7826 } 7827 7828 case strings.EqualFold("UploadIdMarker", t.Name.Local): 7829 val, err := decoder.Value() 7830 if err != nil { 7831 return err 7832 } 7833 if val == nil { 7834 break 7835 } 7836 { 7837 xtv := string(val) 7838 sv.UploadIdMarker = ptr.String(xtv) 7839 } 7840 7841 case strings.EqualFold("Upload", t.Name.Local): 7842 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7843 if err := awsRestxml_deserializeDocumentMultipartUploadListUnwrapped(&sv.Uploads, nodeDecoder); err != nil { 7844 return err 7845 } 7846 7847 default: 7848 // Do nothing and ignore the unexpected tag element 7849 err = decoder.Decoder.Skip() 7850 if err != nil { 7851 return err 7852 } 7853 7854 } 7855 decoder = originalDecoder 7856 } 7857 *v = sv 7858 return nil 7859} 7860 7861type awsRestxml_deserializeOpListObjects struct { 7862} 7863 7864func (*awsRestxml_deserializeOpListObjects) ID() string { 7865 return "OperationDeserializer" 7866} 7867 7868func (m *awsRestxml_deserializeOpListObjects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7869 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7870) { 7871 out, metadata, err = next.HandleDeserialize(ctx, in) 7872 if err != nil { 7873 return out, metadata, err 7874 } 7875 7876 response, ok := out.RawResponse.(*smithyhttp.Response) 7877 if !ok { 7878 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7879 } 7880 7881 if response.StatusCode < 200 || response.StatusCode >= 300 { 7882 return out, metadata, awsRestxml_deserializeOpErrorListObjects(response, &metadata) 7883 } 7884 output := &ListObjectsOutput{} 7885 out.Result = output 7886 7887 var buff [1024]byte 7888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7889 body := io.TeeReader(response.Body, ringBuffer) 7890 rootDecoder := xml.NewDecoder(body) 7891 t, err := smithyxml.FetchRootElement(rootDecoder) 7892 if err == io.EOF { 7893 return out, metadata, nil 7894 } 7895 if err != nil { 7896 var snapshot bytes.Buffer 7897 io.Copy(&snapshot, ringBuffer) 7898 return out, metadata, &smithy.DeserializationError{ 7899 Err: fmt.Errorf("failed to decode response body, %w", err), 7900 Snapshot: snapshot.Bytes(), 7901 } 7902 } 7903 7904 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 7905 err = awsRestxml_deserializeOpDocumentListObjectsOutput(&output, decoder) 7906 if err != nil { 7907 var snapshot bytes.Buffer 7908 io.Copy(&snapshot, ringBuffer) 7909 return out, metadata, &smithy.DeserializationError{ 7910 Err: fmt.Errorf("failed to decode response body, %w", err), 7911 Snapshot: snapshot.Bytes(), 7912 } 7913 } 7914 7915 return out, metadata, err 7916} 7917 7918func awsRestxml_deserializeOpErrorListObjects(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7919 var errorBuffer bytes.Buffer 7920 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7921 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7922 } 7923 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7924 7925 errorCode := "UnknownError" 7926 errorMessage := errorCode 7927 7928 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 7929 UseStatusCode: true, StatusCode: response.StatusCode, 7930 }) 7931 if err != nil { 7932 return err 7933 } 7934 if hostID := errorComponents.HostID; len(hostID) != 0 { 7935 s3shared.SetHostIDMetadata(metadata, hostID) 7936 } 7937 if reqID := errorComponents.RequestID; len(reqID) != 0 { 7938 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 7939 } 7940 if len(errorComponents.Code) != 0 { 7941 errorCode = errorComponents.Code 7942 } 7943 if len(errorComponents.Message) != 0 { 7944 errorMessage = errorComponents.Message 7945 } 7946 errorBody.Seek(0, io.SeekStart) 7947 switch { 7948 case strings.EqualFold("NoSuchBucket", errorCode): 7949 return awsRestxml_deserializeErrorNoSuchBucket(response, errorBody) 7950 7951 default: 7952 genericError := &smithy.GenericAPIError{ 7953 Code: errorCode, 7954 Message: errorMessage, 7955 } 7956 return genericError 7957 7958 } 7959} 7960 7961func awsRestxml_deserializeOpDocumentListObjectsOutput(v **ListObjectsOutput, decoder smithyxml.NodeDecoder) error { 7962 if v == nil { 7963 return fmt.Errorf("unexpected nil of type %T", v) 7964 } 7965 var sv *ListObjectsOutput 7966 if *v == nil { 7967 sv = &ListObjectsOutput{} 7968 } else { 7969 sv = *v 7970 } 7971 7972 for { 7973 t, done, err := decoder.Token() 7974 if err != nil { 7975 return err 7976 } 7977 if done { 7978 break 7979 } 7980 originalDecoder := decoder 7981 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 7982 switch { 7983 case strings.EqualFold("CommonPrefixes", t.Name.Local): 7984 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7985 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 7986 return err 7987 } 7988 7989 case strings.EqualFold("Contents", t.Name.Local): 7990 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 7991 if err := awsRestxml_deserializeDocumentObjectListUnwrapped(&sv.Contents, nodeDecoder); err != nil { 7992 return err 7993 } 7994 7995 case strings.EqualFold("Delimiter", t.Name.Local): 7996 val, err := decoder.Value() 7997 if err != nil { 7998 return err 7999 } 8000 if val == nil { 8001 break 8002 } 8003 { 8004 xtv := string(val) 8005 sv.Delimiter = ptr.String(xtv) 8006 } 8007 8008 case strings.EqualFold("EncodingType", t.Name.Local): 8009 val, err := decoder.Value() 8010 if err != nil { 8011 return err 8012 } 8013 if val == nil { 8014 break 8015 } 8016 { 8017 xtv := string(val) 8018 sv.EncodingType = types.EncodingType(xtv) 8019 } 8020 8021 case strings.EqualFold("IsTruncated", t.Name.Local): 8022 val, err := decoder.Value() 8023 if err != nil { 8024 return err 8025 } 8026 if val == nil { 8027 break 8028 } 8029 { 8030 xtv, err := strconv.ParseBool(string(val)) 8031 if err != nil { 8032 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8033 } 8034 sv.IsTruncated = xtv 8035 } 8036 8037 case strings.EqualFold("Marker", t.Name.Local): 8038 val, err := decoder.Value() 8039 if err != nil { 8040 return err 8041 } 8042 if val == nil { 8043 break 8044 } 8045 { 8046 xtv := string(val) 8047 sv.Marker = ptr.String(xtv) 8048 } 8049 8050 case strings.EqualFold("MaxKeys", t.Name.Local): 8051 val, err := decoder.Value() 8052 if err != nil { 8053 return err 8054 } 8055 if val == nil { 8056 break 8057 } 8058 { 8059 xtv := string(val) 8060 i64, err := strconv.ParseInt(xtv, 10, 64) 8061 if err != nil { 8062 return err 8063 } 8064 sv.MaxKeys = int32(i64) 8065 } 8066 8067 case strings.EqualFold("Name", t.Name.Local): 8068 val, err := decoder.Value() 8069 if err != nil { 8070 return err 8071 } 8072 if val == nil { 8073 break 8074 } 8075 { 8076 xtv := string(val) 8077 sv.Name = ptr.String(xtv) 8078 } 8079 8080 case strings.EqualFold("NextMarker", t.Name.Local): 8081 val, err := decoder.Value() 8082 if err != nil { 8083 return err 8084 } 8085 if val == nil { 8086 break 8087 } 8088 { 8089 xtv := string(val) 8090 sv.NextMarker = ptr.String(xtv) 8091 } 8092 8093 case strings.EqualFold("Prefix", t.Name.Local): 8094 val, err := decoder.Value() 8095 if err != nil { 8096 return err 8097 } 8098 if val == nil { 8099 break 8100 } 8101 { 8102 xtv := string(val) 8103 sv.Prefix = ptr.String(xtv) 8104 } 8105 8106 default: 8107 // Do nothing and ignore the unexpected tag element 8108 err = decoder.Decoder.Skip() 8109 if err != nil { 8110 return err 8111 } 8112 8113 } 8114 decoder = originalDecoder 8115 } 8116 *v = sv 8117 return nil 8118} 8119 8120type awsRestxml_deserializeOpListObjectsV2 struct { 8121} 8122 8123func (*awsRestxml_deserializeOpListObjectsV2) ID() string { 8124 return "OperationDeserializer" 8125} 8126 8127func (m *awsRestxml_deserializeOpListObjectsV2) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8128 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8129) { 8130 out, metadata, err = next.HandleDeserialize(ctx, in) 8131 if err != nil { 8132 return out, metadata, err 8133 } 8134 8135 response, ok := out.RawResponse.(*smithyhttp.Response) 8136 if !ok { 8137 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8138 } 8139 8140 if response.StatusCode < 200 || response.StatusCode >= 300 { 8141 return out, metadata, awsRestxml_deserializeOpErrorListObjectsV2(response, &metadata) 8142 } 8143 output := &ListObjectsV2Output{} 8144 out.Result = output 8145 8146 var buff [1024]byte 8147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8148 body := io.TeeReader(response.Body, ringBuffer) 8149 rootDecoder := xml.NewDecoder(body) 8150 t, err := smithyxml.FetchRootElement(rootDecoder) 8151 if err == io.EOF { 8152 return out, metadata, nil 8153 } 8154 if err != nil { 8155 var snapshot bytes.Buffer 8156 io.Copy(&snapshot, ringBuffer) 8157 return out, metadata, &smithy.DeserializationError{ 8158 Err: fmt.Errorf("failed to decode response body, %w", err), 8159 Snapshot: snapshot.Bytes(), 8160 } 8161 } 8162 8163 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8164 err = awsRestxml_deserializeOpDocumentListObjectsV2Output(&output, decoder) 8165 if err != nil { 8166 var snapshot bytes.Buffer 8167 io.Copy(&snapshot, ringBuffer) 8168 return out, metadata, &smithy.DeserializationError{ 8169 Err: fmt.Errorf("failed to decode response body, %w", err), 8170 Snapshot: snapshot.Bytes(), 8171 } 8172 } 8173 8174 return out, metadata, err 8175} 8176 8177func awsRestxml_deserializeOpErrorListObjectsV2(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8178 var errorBuffer bytes.Buffer 8179 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8180 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8181 } 8182 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8183 8184 errorCode := "UnknownError" 8185 errorMessage := errorCode 8186 8187 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 8188 UseStatusCode: true, StatusCode: response.StatusCode, 8189 }) 8190 if err != nil { 8191 return err 8192 } 8193 if hostID := errorComponents.HostID; len(hostID) != 0 { 8194 s3shared.SetHostIDMetadata(metadata, hostID) 8195 } 8196 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8197 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8198 } 8199 if len(errorComponents.Code) != 0 { 8200 errorCode = errorComponents.Code 8201 } 8202 if len(errorComponents.Message) != 0 { 8203 errorMessage = errorComponents.Message 8204 } 8205 errorBody.Seek(0, io.SeekStart) 8206 switch { 8207 case strings.EqualFold("NoSuchBucket", errorCode): 8208 return awsRestxml_deserializeErrorNoSuchBucket(response, errorBody) 8209 8210 default: 8211 genericError := &smithy.GenericAPIError{ 8212 Code: errorCode, 8213 Message: errorMessage, 8214 } 8215 return genericError 8216 8217 } 8218} 8219 8220func awsRestxml_deserializeOpDocumentListObjectsV2Output(v **ListObjectsV2Output, decoder smithyxml.NodeDecoder) error { 8221 if v == nil { 8222 return fmt.Errorf("unexpected nil of type %T", v) 8223 } 8224 var sv *ListObjectsV2Output 8225 if *v == nil { 8226 sv = &ListObjectsV2Output{} 8227 } else { 8228 sv = *v 8229 } 8230 8231 for { 8232 t, done, err := decoder.Token() 8233 if err != nil { 8234 return err 8235 } 8236 if done { 8237 break 8238 } 8239 originalDecoder := decoder 8240 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8241 switch { 8242 case strings.EqualFold("CommonPrefixes", t.Name.Local): 8243 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8244 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 8245 return err 8246 } 8247 8248 case strings.EqualFold("Contents", t.Name.Local): 8249 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8250 if err := awsRestxml_deserializeDocumentObjectListUnwrapped(&sv.Contents, nodeDecoder); err != nil { 8251 return err 8252 } 8253 8254 case strings.EqualFold("ContinuationToken", t.Name.Local): 8255 val, err := decoder.Value() 8256 if err != nil { 8257 return err 8258 } 8259 if val == nil { 8260 break 8261 } 8262 { 8263 xtv := string(val) 8264 sv.ContinuationToken = ptr.String(xtv) 8265 } 8266 8267 case strings.EqualFold("Delimiter", t.Name.Local): 8268 val, err := decoder.Value() 8269 if err != nil { 8270 return err 8271 } 8272 if val == nil { 8273 break 8274 } 8275 { 8276 xtv := string(val) 8277 sv.Delimiter = ptr.String(xtv) 8278 } 8279 8280 case strings.EqualFold("EncodingType", t.Name.Local): 8281 val, err := decoder.Value() 8282 if err != nil { 8283 return err 8284 } 8285 if val == nil { 8286 break 8287 } 8288 { 8289 xtv := string(val) 8290 sv.EncodingType = types.EncodingType(xtv) 8291 } 8292 8293 case strings.EqualFold("IsTruncated", t.Name.Local): 8294 val, err := decoder.Value() 8295 if err != nil { 8296 return err 8297 } 8298 if val == nil { 8299 break 8300 } 8301 { 8302 xtv, err := strconv.ParseBool(string(val)) 8303 if err != nil { 8304 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8305 } 8306 sv.IsTruncated = xtv 8307 } 8308 8309 case strings.EqualFold("KeyCount", t.Name.Local): 8310 val, err := decoder.Value() 8311 if err != nil { 8312 return err 8313 } 8314 if val == nil { 8315 break 8316 } 8317 { 8318 xtv := string(val) 8319 i64, err := strconv.ParseInt(xtv, 10, 64) 8320 if err != nil { 8321 return err 8322 } 8323 sv.KeyCount = int32(i64) 8324 } 8325 8326 case strings.EqualFold("MaxKeys", t.Name.Local): 8327 val, err := decoder.Value() 8328 if err != nil { 8329 return err 8330 } 8331 if val == nil { 8332 break 8333 } 8334 { 8335 xtv := string(val) 8336 i64, err := strconv.ParseInt(xtv, 10, 64) 8337 if err != nil { 8338 return err 8339 } 8340 sv.MaxKeys = int32(i64) 8341 } 8342 8343 case strings.EqualFold("Name", t.Name.Local): 8344 val, err := decoder.Value() 8345 if err != nil { 8346 return err 8347 } 8348 if val == nil { 8349 break 8350 } 8351 { 8352 xtv := string(val) 8353 sv.Name = ptr.String(xtv) 8354 } 8355 8356 case strings.EqualFold("NextContinuationToken", t.Name.Local): 8357 val, err := decoder.Value() 8358 if err != nil { 8359 return err 8360 } 8361 if val == nil { 8362 break 8363 } 8364 { 8365 xtv := string(val) 8366 sv.NextContinuationToken = ptr.String(xtv) 8367 } 8368 8369 case strings.EqualFold("Prefix", t.Name.Local): 8370 val, err := decoder.Value() 8371 if err != nil { 8372 return err 8373 } 8374 if val == nil { 8375 break 8376 } 8377 { 8378 xtv := string(val) 8379 sv.Prefix = ptr.String(xtv) 8380 } 8381 8382 case strings.EqualFold("StartAfter", t.Name.Local): 8383 val, err := decoder.Value() 8384 if err != nil { 8385 return err 8386 } 8387 if val == nil { 8388 break 8389 } 8390 { 8391 xtv := string(val) 8392 sv.StartAfter = ptr.String(xtv) 8393 } 8394 8395 default: 8396 // Do nothing and ignore the unexpected tag element 8397 err = decoder.Decoder.Skip() 8398 if err != nil { 8399 return err 8400 } 8401 8402 } 8403 decoder = originalDecoder 8404 } 8405 *v = sv 8406 return nil 8407} 8408 8409type awsRestxml_deserializeOpListObjectVersions struct { 8410} 8411 8412func (*awsRestxml_deserializeOpListObjectVersions) ID() string { 8413 return "OperationDeserializer" 8414} 8415 8416func (m *awsRestxml_deserializeOpListObjectVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8417 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8418) { 8419 out, metadata, err = next.HandleDeserialize(ctx, in) 8420 if err != nil { 8421 return out, metadata, err 8422 } 8423 8424 response, ok := out.RawResponse.(*smithyhttp.Response) 8425 if !ok { 8426 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8427 } 8428 8429 if response.StatusCode < 200 || response.StatusCode >= 300 { 8430 return out, metadata, awsRestxml_deserializeOpErrorListObjectVersions(response, &metadata) 8431 } 8432 output := &ListObjectVersionsOutput{} 8433 out.Result = output 8434 8435 var buff [1024]byte 8436 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8437 body := io.TeeReader(response.Body, ringBuffer) 8438 rootDecoder := xml.NewDecoder(body) 8439 t, err := smithyxml.FetchRootElement(rootDecoder) 8440 if err == io.EOF { 8441 return out, metadata, nil 8442 } 8443 if err != nil { 8444 var snapshot bytes.Buffer 8445 io.Copy(&snapshot, ringBuffer) 8446 return out, metadata, &smithy.DeserializationError{ 8447 Err: fmt.Errorf("failed to decode response body, %w", err), 8448 Snapshot: snapshot.Bytes(), 8449 } 8450 } 8451 8452 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8453 err = awsRestxml_deserializeOpDocumentListObjectVersionsOutput(&output, decoder) 8454 if err != nil { 8455 var snapshot bytes.Buffer 8456 io.Copy(&snapshot, ringBuffer) 8457 return out, metadata, &smithy.DeserializationError{ 8458 Err: fmt.Errorf("failed to decode response body, %w", err), 8459 Snapshot: snapshot.Bytes(), 8460 } 8461 } 8462 8463 return out, metadata, err 8464} 8465 8466func awsRestxml_deserializeOpErrorListObjectVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8467 var errorBuffer bytes.Buffer 8468 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8469 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8470 } 8471 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8472 8473 errorCode := "UnknownError" 8474 errorMessage := errorCode 8475 8476 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 8477 UseStatusCode: true, StatusCode: response.StatusCode, 8478 }) 8479 if err != nil { 8480 return err 8481 } 8482 if hostID := errorComponents.HostID; len(hostID) != 0 { 8483 s3shared.SetHostIDMetadata(metadata, hostID) 8484 } 8485 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8486 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8487 } 8488 if len(errorComponents.Code) != 0 { 8489 errorCode = errorComponents.Code 8490 } 8491 if len(errorComponents.Message) != 0 { 8492 errorMessage = errorComponents.Message 8493 } 8494 errorBody.Seek(0, io.SeekStart) 8495 switch { 8496 default: 8497 genericError := &smithy.GenericAPIError{ 8498 Code: errorCode, 8499 Message: errorMessage, 8500 } 8501 return genericError 8502 8503 } 8504} 8505 8506func awsRestxml_deserializeOpDocumentListObjectVersionsOutput(v **ListObjectVersionsOutput, decoder smithyxml.NodeDecoder) error { 8507 if v == nil { 8508 return fmt.Errorf("unexpected nil of type %T", v) 8509 } 8510 var sv *ListObjectVersionsOutput 8511 if *v == nil { 8512 sv = &ListObjectVersionsOutput{} 8513 } else { 8514 sv = *v 8515 } 8516 8517 for { 8518 t, done, err := decoder.Token() 8519 if err != nil { 8520 return err 8521 } 8522 if done { 8523 break 8524 } 8525 originalDecoder := decoder 8526 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8527 switch { 8528 case strings.EqualFold("CommonPrefixes", t.Name.Local): 8529 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8530 if err := awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(&sv.CommonPrefixes, nodeDecoder); err != nil { 8531 return err 8532 } 8533 8534 case strings.EqualFold("DeleteMarker", t.Name.Local): 8535 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8536 if err := awsRestxml_deserializeDocumentDeleteMarkersUnwrapped(&sv.DeleteMarkers, nodeDecoder); err != nil { 8537 return err 8538 } 8539 8540 case strings.EqualFold("Delimiter", t.Name.Local): 8541 val, err := decoder.Value() 8542 if err != nil { 8543 return err 8544 } 8545 if val == nil { 8546 break 8547 } 8548 { 8549 xtv := string(val) 8550 sv.Delimiter = ptr.String(xtv) 8551 } 8552 8553 case strings.EqualFold("EncodingType", t.Name.Local): 8554 val, err := decoder.Value() 8555 if err != nil { 8556 return err 8557 } 8558 if val == nil { 8559 break 8560 } 8561 { 8562 xtv := string(val) 8563 sv.EncodingType = types.EncodingType(xtv) 8564 } 8565 8566 case strings.EqualFold("IsTruncated", t.Name.Local): 8567 val, err := decoder.Value() 8568 if err != nil { 8569 return err 8570 } 8571 if val == nil { 8572 break 8573 } 8574 { 8575 xtv, err := strconv.ParseBool(string(val)) 8576 if err != nil { 8577 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8578 } 8579 sv.IsTruncated = xtv 8580 } 8581 8582 case strings.EqualFold("KeyMarker", t.Name.Local): 8583 val, err := decoder.Value() 8584 if err != nil { 8585 return err 8586 } 8587 if val == nil { 8588 break 8589 } 8590 { 8591 xtv := string(val) 8592 sv.KeyMarker = ptr.String(xtv) 8593 } 8594 8595 case strings.EqualFold("MaxKeys", t.Name.Local): 8596 val, err := decoder.Value() 8597 if err != nil { 8598 return err 8599 } 8600 if val == nil { 8601 break 8602 } 8603 { 8604 xtv := string(val) 8605 i64, err := strconv.ParseInt(xtv, 10, 64) 8606 if err != nil { 8607 return err 8608 } 8609 sv.MaxKeys = int32(i64) 8610 } 8611 8612 case strings.EqualFold("Name", t.Name.Local): 8613 val, err := decoder.Value() 8614 if err != nil { 8615 return err 8616 } 8617 if val == nil { 8618 break 8619 } 8620 { 8621 xtv := string(val) 8622 sv.Name = ptr.String(xtv) 8623 } 8624 8625 case strings.EqualFold("NextKeyMarker", t.Name.Local): 8626 val, err := decoder.Value() 8627 if err != nil { 8628 return err 8629 } 8630 if val == nil { 8631 break 8632 } 8633 { 8634 xtv := string(val) 8635 sv.NextKeyMarker = ptr.String(xtv) 8636 } 8637 8638 case strings.EqualFold("NextVersionIdMarker", t.Name.Local): 8639 val, err := decoder.Value() 8640 if err != nil { 8641 return err 8642 } 8643 if val == nil { 8644 break 8645 } 8646 { 8647 xtv := string(val) 8648 sv.NextVersionIdMarker = ptr.String(xtv) 8649 } 8650 8651 case strings.EqualFold("Prefix", t.Name.Local): 8652 val, err := decoder.Value() 8653 if err != nil { 8654 return err 8655 } 8656 if val == nil { 8657 break 8658 } 8659 { 8660 xtv := string(val) 8661 sv.Prefix = ptr.String(xtv) 8662 } 8663 8664 case strings.EqualFold("VersionIdMarker", t.Name.Local): 8665 val, err := decoder.Value() 8666 if err != nil { 8667 return err 8668 } 8669 if val == nil { 8670 break 8671 } 8672 { 8673 xtv := string(val) 8674 sv.VersionIdMarker = ptr.String(xtv) 8675 } 8676 8677 case strings.EqualFold("Version", t.Name.Local): 8678 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8679 if err := awsRestxml_deserializeDocumentObjectVersionListUnwrapped(&sv.Versions, nodeDecoder); err != nil { 8680 return err 8681 } 8682 8683 default: 8684 // Do nothing and ignore the unexpected tag element 8685 err = decoder.Decoder.Skip() 8686 if err != nil { 8687 return err 8688 } 8689 8690 } 8691 decoder = originalDecoder 8692 } 8693 *v = sv 8694 return nil 8695} 8696 8697type awsRestxml_deserializeOpListParts struct { 8698} 8699 8700func (*awsRestxml_deserializeOpListParts) ID() string { 8701 return "OperationDeserializer" 8702} 8703 8704func (m *awsRestxml_deserializeOpListParts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8705 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8706) { 8707 out, metadata, err = next.HandleDeserialize(ctx, in) 8708 if err != nil { 8709 return out, metadata, err 8710 } 8711 8712 response, ok := out.RawResponse.(*smithyhttp.Response) 8713 if !ok { 8714 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8715 } 8716 8717 if response.StatusCode < 200 || response.StatusCode >= 300 { 8718 return out, metadata, awsRestxml_deserializeOpErrorListParts(response, &metadata) 8719 } 8720 output := &ListPartsOutput{} 8721 out.Result = output 8722 8723 err = awsRestxml_deserializeOpHttpBindingsListPartsOutput(output, response) 8724 if err != nil { 8725 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 8726 } 8727 8728 var buff [1024]byte 8729 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8730 body := io.TeeReader(response.Body, ringBuffer) 8731 rootDecoder := xml.NewDecoder(body) 8732 t, err := smithyxml.FetchRootElement(rootDecoder) 8733 if err == io.EOF { 8734 return out, metadata, nil 8735 } 8736 if err != nil { 8737 var snapshot bytes.Buffer 8738 io.Copy(&snapshot, ringBuffer) 8739 return out, metadata, &smithy.DeserializationError{ 8740 Err: fmt.Errorf("failed to decode response body, %w", err), 8741 Snapshot: snapshot.Bytes(), 8742 } 8743 } 8744 8745 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 8746 err = awsRestxml_deserializeOpDocumentListPartsOutput(&output, decoder) 8747 if err != nil { 8748 var snapshot bytes.Buffer 8749 io.Copy(&snapshot, ringBuffer) 8750 return out, metadata, &smithy.DeserializationError{ 8751 Err: fmt.Errorf("failed to decode response body, %w", err), 8752 Snapshot: snapshot.Bytes(), 8753 } 8754 } 8755 8756 return out, metadata, err 8757} 8758 8759func awsRestxml_deserializeOpErrorListParts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8760 var errorBuffer bytes.Buffer 8761 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8762 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8763 } 8764 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8765 8766 errorCode := "UnknownError" 8767 errorMessage := errorCode 8768 8769 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 8770 UseStatusCode: true, StatusCode: response.StatusCode, 8771 }) 8772 if err != nil { 8773 return err 8774 } 8775 if hostID := errorComponents.HostID; len(hostID) != 0 { 8776 s3shared.SetHostIDMetadata(metadata, hostID) 8777 } 8778 if reqID := errorComponents.RequestID; len(reqID) != 0 { 8779 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 8780 } 8781 if len(errorComponents.Code) != 0 { 8782 errorCode = errorComponents.Code 8783 } 8784 if len(errorComponents.Message) != 0 { 8785 errorMessage = errorComponents.Message 8786 } 8787 errorBody.Seek(0, io.SeekStart) 8788 switch { 8789 default: 8790 genericError := &smithy.GenericAPIError{ 8791 Code: errorCode, 8792 Message: errorMessage, 8793 } 8794 return genericError 8795 8796 } 8797} 8798 8799func awsRestxml_deserializeOpHttpBindingsListPartsOutput(v *ListPartsOutput, response *smithyhttp.Response) error { 8800 if v == nil { 8801 return fmt.Errorf("unsupported deserialization for nil %T", v) 8802 } 8803 8804 if headerValues := response.Header.Values("x-amz-abort-date"); len(headerValues) != 0 { 8805 headerValues[0] = strings.TrimSpace(headerValues[0]) 8806 t, err := smithytime.ParseHTTPDate(headerValues[0]) 8807 if err != nil { 8808 return err 8809 } 8810 v.AbortDate = ptr.Time(t) 8811 } 8812 8813 if headerValues := response.Header.Values("x-amz-abort-rule-id"); len(headerValues) != 0 { 8814 headerValues[0] = strings.TrimSpace(headerValues[0]) 8815 v.AbortRuleId = ptr.String(headerValues[0]) 8816 } 8817 8818 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 8819 headerValues[0] = strings.TrimSpace(headerValues[0]) 8820 v.RequestCharged = types.RequestCharged(headerValues[0]) 8821 } 8822 8823 return nil 8824} 8825func awsRestxml_deserializeOpDocumentListPartsOutput(v **ListPartsOutput, decoder smithyxml.NodeDecoder) error { 8826 if v == nil { 8827 return fmt.Errorf("unexpected nil of type %T", v) 8828 } 8829 var sv *ListPartsOutput 8830 if *v == nil { 8831 sv = &ListPartsOutput{} 8832 } else { 8833 sv = *v 8834 } 8835 8836 for { 8837 t, done, err := decoder.Token() 8838 if err != nil { 8839 return err 8840 } 8841 if done { 8842 break 8843 } 8844 originalDecoder := decoder 8845 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 8846 switch { 8847 case strings.EqualFold("Bucket", t.Name.Local): 8848 val, err := decoder.Value() 8849 if err != nil { 8850 return err 8851 } 8852 if val == nil { 8853 break 8854 } 8855 { 8856 xtv := string(val) 8857 sv.Bucket = ptr.String(xtv) 8858 } 8859 8860 case strings.EqualFold("Initiator", t.Name.Local): 8861 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8862 if err := awsRestxml_deserializeDocumentInitiator(&sv.Initiator, nodeDecoder); err != nil { 8863 return err 8864 } 8865 8866 case strings.EqualFold("IsTruncated", t.Name.Local): 8867 val, err := decoder.Value() 8868 if err != nil { 8869 return err 8870 } 8871 if val == nil { 8872 break 8873 } 8874 { 8875 xtv, err := strconv.ParseBool(string(val)) 8876 if err != nil { 8877 return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val) 8878 } 8879 sv.IsTruncated = xtv 8880 } 8881 8882 case strings.EqualFold("Key", t.Name.Local): 8883 val, err := decoder.Value() 8884 if err != nil { 8885 return err 8886 } 8887 if val == nil { 8888 break 8889 } 8890 { 8891 xtv := string(val) 8892 sv.Key = ptr.String(xtv) 8893 } 8894 8895 case strings.EqualFold("MaxParts", t.Name.Local): 8896 val, err := decoder.Value() 8897 if err != nil { 8898 return err 8899 } 8900 if val == nil { 8901 break 8902 } 8903 { 8904 xtv := string(val) 8905 i64, err := strconv.ParseInt(xtv, 10, 64) 8906 if err != nil { 8907 return err 8908 } 8909 sv.MaxParts = int32(i64) 8910 } 8911 8912 case strings.EqualFold("NextPartNumberMarker", t.Name.Local): 8913 val, err := decoder.Value() 8914 if err != nil { 8915 return err 8916 } 8917 if val == nil { 8918 break 8919 } 8920 { 8921 xtv := string(val) 8922 sv.NextPartNumberMarker = ptr.String(xtv) 8923 } 8924 8925 case strings.EqualFold("Owner", t.Name.Local): 8926 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8927 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 8928 return err 8929 } 8930 8931 case strings.EqualFold("PartNumberMarker", t.Name.Local): 8932 val, err := decoder.Value() 8933 if err != nil { 8934 return err 8935 } 8936 if val == nil { 8937 break 8938 } 8939 { 8940 xtv := string(val) 8941 sv.PartNumberMarker = ptr.String(xtv) 8942 } 8943 8944 case strings.EqualFold("Part", t.Name.Local): 8945 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 8946 if err := awsRestxml_deserializeDocumentPartsUnwrapped(&sv.Parts, nodeDecoder); err != nil { 8947 return err 8948 } 8949 8950 case strings.EqualFold("StorageClass", t.Name.Local): 8951 val, err := decoder.Value() 8952 if err != nil { 8953 return err 8954 } 8955 if val == nil { 8956 break 8957 } 8958 { 8959 xtv := string(val) 8960 sv.StorageClass = types.StorageClass(xtv) 8961 } 8962 8963 case strings.EqualFold("UploadId", t.Name.Local): 8964 val, err := decoder.Value() 8965 if err != nil { 8966 return err 8967 } 8968 if val == nil { 8969 break 8970 } 8971 { 8972 xtv := string(val) 8973 sv.UploadId = ptr.String(xtv) 8974 } 8975 8976 default: 8977 // Do nothing and ignore the unexpected tag element 8978 err = decoder.Decoder.Skip() 8979 if err != nil { 8980 return err 8981 } 8982 8983 } 8984 decoder = originalDecoder 8985 } 8986 *v = sv 8987 return nil 8988} 8989 8990type awsRestxml_deserializeOpPutBucketAccelerateConfiguration struct { 8991} 8992 8993func (*awsRestxml_deserializeOpPutBucketAccelerateConfiguration) ID() string { 8994 return "OperationDeserializer" 8995} 8996 8997func (m *awsRestxml_deserializeOpPutBucketAccelerateConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8998 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8999) { 9000 out, metadata, err = next.HandleDeserialize(ctx, in) 9001 if err != nil { 9002 return out, metadata, err 9003 } 9004 9005 response, ok := out.RawResponse.(*smithyhttp.Response) 9006 if !ok { 9007 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9008 } 9009 9010 if response.StatusCode < 200 || response.StatusCode >= 300 { 9011 return out, metadata, awsRestxml_deserializeOpErrorPutBucketAccelerateConfiguration(response, &metadata) 9012 } 9013 output := &PutBucketAccelerateConfigurationOutput{} 9014 out.Result = output 9015 9016 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9017 return out, metadata, &smithy.DeserializationError{ 9018 Err: fmt.Errorf("failed to discard response body, %w", err), 9019 } 9020 } 9021 9022 return out, metadata, err 9023} 9024 9025func awsRestxml_deserializeOpErrorPutBucketAccelerateConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9026 var errorBuffer bytes.Buffer 9027 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9028 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9029 } 9030 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9031 9032 errorCode := "UnknownError" 9033 errorMessage := errorCode 9034 9035 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9036 UseStatusCode: true, StatusCode: response.StatusCode, 9037 }) 9038 if err != nil { 9039 return err 9040 } 9041 if hostID := errorComponents.HostID; len(hostID) != 0 { 9042 s3shared.SetHostIDMetadata(metadata, hostID) 9043 } 9044 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9045 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9046 } 9047 if len(errorComponents.Code) != 0 { 9048 errorCode = errorComponents.Code 9049 } 9050 if len(errorComponents.Message) != 0 { 9051 errorMessage = errorComponents.Message 9052 } 9053 errorBody.Seek(0, io.SeekStart) 9054 switch { 9055 default: 9056 genericError := &smithy.GenericAPIError{ 9057 Code: errorCode, 9058 Message: errorMessage, 9059 } 9060 return genericError 9061 9062 } 9063} 9064 9065type awsRestxml_deserializeOpPutBucketAcl struct { 9066} 9067 9068func (*awsRestxml_deserializeOpPutBucketAcl) ID() string { 9069 return "OperationDeserializer" 9070} 9071 9072func (m *awsRestxml_deserializeOpPutBucketAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9073 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9074) { 9075 out, metadata, err = next.HandleDeserialize(ctx, in) 9076 if err != nil { 9077 return out, metadata, err 9078 } 9079 9080 response, ok := out.RawResponse.(*smithyhttp.Response) 9081 if !ok { 9082 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9083 } 9084 9085 if response.StatusCode < 200 || response.StatusCode >= 300 { 9086 return out, metadata, awsRestxml_deserializeOpErrorPutBucketAcl(response, &metadata) 9087 } 9088 output := &PutBucketAclOutput{} 9089 out.Result = output 9090 9091 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9092 return out, metadata, &smithy.DeserializationError{ 9093 Err: fmt.Errorf("failed to discard response body, %w", err), 9094 } 9095 } 9096 9097 return out, metadata, err 9098} 9099 9100func awsRestxml_deserializeOpErrorPutBucketAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9101 var errorBuffer bytes.Buffer 9102 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9103 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9104 } 9105 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9106 9107 errorCode := "UnknownError" 9108 errorMessage := errorCode 9109 9110 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9111 UseStatusCode: true, StatusCode: response.StatusCode, 9112 }) 9113 if err != nil { 9114 return err 9115 } 9116 if hostID := errorComponents.HostID; len(hostID) != 0 { 9117 s3shared.SetHostIDMetadata(metadata, hostID) 9118 } 9119 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9120 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9121 } 9122 if len(errorComponents.Code) != 0 { 9123 errorCode = errorComponents.Code 9124 } 9125 if len(errorComponents.Message) != 0 { 9126 errorMessage = errorComponents.Message 9127 } 9128 errorBody.Seek(0, io.SeekStart) 9129 switch { 9130 default: 9131 genericError := &smithy.GenericAPIError{ 9132 Code: errorCode, 9133 Message: errorMessage, 9134 } 9135 return genericError 9136 9137 } 9138} 9139 9140type awsRestxml_deserializeOpPutBucketAnalyticsConfiguration struct { 9141} 9142 9143func (*awsRestxml_deserializeOpPutBucketAnalyticsConfiguration) ID() string { 9144 return "OperationDeserializer" 9145} 9146 9147func (m *awsRestxml_deserializeOpPutBucketAnalyticsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9148 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9149) { 9150 out, metadata, err = next.HandleDeserialize(ctx, in) 9151 if err != nil { 9152 return out, metadata, err 9153 } 9154 9155 response, ok := out.RawResponse.(*smithyhttp.Response) 9156 if !ok { 9157 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9158 } 9159 9160 if response.StatusCode < 200 || response.StatusCode >= 300 { 9161 return out, metadata, awsRestxml_deserializeOpErrorPutBucketAnalyticsConfiguration(response, &metadata) 9162 } 9163 output := &PutBucketAnalyticsConfigurationOutput{} 9164 out.Result = output 9165 9166 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9167 return out, metadata, &smithy.DeserializationError{ 9168 Err: fmt.Errorf("failed to discard response body, %w", err), 9169 } 9170 } 9171 9172 return out, metadata, err 9173} 9174 9175func awsRestxml_deserializeOpErrorPutBucketAnalyticsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9176 var errorBuffer bytes.Buffer 9177 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9178 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9179 } 9180 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9181 9182 errorCode := "UnknownError" 9183 errorMessage := errorCode 9184 9185 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9186 UseStatusCode: true, StatusCode: response.StatusCode, 9187 }) 9188 if err != nil { 9189 return err 9190 } 9191 if hostID := errorComponents.HostID; len(hostID) != 0 { 9192 s3shared.SetHostIDMetadata(metadata, hostID) 9193 } 9194 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9195 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9196 } 9197 if len(errorComponents.Code) != 0 { 9198 errorCode = errorComponents.Code 9199 } 9200 if len(errorComponents.Message) != 0 { 9201 errorMessage = errorComponents.Message 9202 } 9203 errorBody.Seek(0, io.SeekStart) 9204 switch { 9205 default: 9206 genericError := &smithy.GenericAPIError{ 9207 Code: errorCode, 9208 Message: errorMessage, 9209 } 9210 return genericError 9211 9212 } 9213} 9214 9215type awsRestxml_deserializeOpPutBucketCors struct { 9216} 9217 9218func (*awsRestxml_deserializeOpPutBucketCors) ID() string { 9219 return "OperationDeserializer" 9220} 9221 9222func (m *awsRestxml_deserializeOpPutBucketCors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9223 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9224) { 9225 out, metadata, err = next.HandleDeserialize(ctx, in) 9226 if err != nil { 9227 return out, metadata, err 9228 } 9229 9230 response, ok := out.RawResponse.(*smithyhttp.Response) 9231 if !ok { 9232 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9233 } 9234 9235 if response.StatusCode < 200 || response.StatusCode >= 300 { 9236 return out, metadata, awsRestxml_deserializeOpErrorPutBucketCors(response, &metadata) 9237 } 9238 output := &PutBucketCorsOutput{} 9239 out.Result = output 9240 9241 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9242 return out, metadata, &smithy.DeserializationError{ 9243 Err: fmt.Errorf("failed to discard response body, %w", err), 9244 } 9245 } 9246 9247 return out, metadata, err 9248} 9249 9250func awsRestxml_deserializeOpErrorPutBucketCors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9251 var errorBuffer bytes.Buffer 9252 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9253 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9254 } 9255 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9256 9257 errorCode := "UnknownError" 9258 errorMessage := errorCode 9259 9260 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9261 UseStatusCode: true, StatusCode: response.StatusCode, 9262 }) 9263 if err != nil { 9264 return err 9265 } 9266 if hostID := errorComponents.HostID; len(hostID) != 0 { 9267 s3shared.SetHostIDMetadata(metadata, hostID) 9268 } 9269 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9270 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9271 } 9272 if len(errorComponents.Code) != 0 { 9273 errorCode = errorComponents.Code 9274 } 9275 if len(errorComponents.Message) != 0 { 9276 errorMessage = errorComponents.Message 9277 } 9278 errorBody.Seek(0, io.SeekStart) 9279 switch { 9280 default: 9281 genericError := &smithy.GenericAPIError{ 9282 Code: errorCode, 9283 Message: errorMessage, 9284 } 9285 return genericError 9286 9287 } 9288} 9289 9290type awsRestxml_deserializeOpPutBucketEncryption struct { 9291} 9292 9293func (*awsRestxml_deserializeOpPutBucketEncryption) ID() string { 9294 return "OperationDeserializer" 9295} 9296 9297func (m *awsRestxml_deserializeOpPutBucketEncryption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9298 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9299) { 9300 out, metadata, err = next.HandleDeserialize(ctx, in) 9301 if err != nil { 9302 return out, metadata, err 9303 } 9304 9305 response, ok := out.RawResponse.(*smithyhttp.Response) 9306 if !ok { 9307 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9308 } 9309 9310 if response.StatusCode < 200 || response.StatusCode >= 300 { 9311 return out, metadata, awsRestxml_deserializeOpErrorPutBucketEncryption(response, &metadata) 9312 } 9313 output := &PutBucketEncryptionOutput{} 9314 out.Result = output 9315 9316 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9317 return out, metadata, &smithy.DeserializationError{ 9318 Err: fmt.Errorf("failed to discard response body, %w", err), 9319 } 9320 } 9321 9322 return out, metadata, err 9323} 9324 9325func awsRestxml_deserializeOpErrorPutBucketEncryption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9326 var errorBuffer bytes.Buffer 9327 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9328 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9329 } 9330 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9331 9332 errorCode := "UnknownError" 9333 errorMessage := errorCode 9334 9335 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9336 UseStatusCode: true, StatusCode: response.StatusCode, 9337 }) 9338 if err != nil { 9339 return err 9340 } 9341 if hostID := errorComponents.HostID; len(hostID) != 0 { 9342 s3shared.SetHostIDMetadata(metadata, hostID) 9343 } 9344 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9345 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9346 } 9347 if len(errorComponents.Code) != 0 { 9348 errorCode = errorComponents.Code 9349 } 9350 if len(errorComponents.Message) != 0 { 9351 errorMessage = errorComponents.Message 9352 } 9353 errorBody.Seek(0, io.SeekStart) 9354 switch { 9355 default: 9356 genericError := &smithy.GenericAPIError{ 9357 Code: errorCode, 9358 Message: errorMessage, 9359 } 9360 return genericError 9361 9362 } 9363} 9364 9365type awsRestxml_deserializeOpPutBucketIntelligentTieringConfiguration struct { 9366} 9367 9368func (*awsRestxml_deserializeOpPutBucketIntelligentTieringConfiguration) ID() string { 9369 return "OperationDeserializer" 9370} 9371 9372func (m *awsRestxml_deserializeOpPutBucketIntelligentTieringConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9373 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9374) { 9375 out, metadata, err = next.HandleDeserialize(ctx, in) 9376 if err != nil { 9377 return out, metadata, err 9378 } 9379 9380 response, ok := out.RawResponse.(*smithyhttp.Response) 9381 if !ok { 9382 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9383 } 9384 9385 if response.StatusCode < 200 || response.StatusCode >= 300 { 9386 return out, metadata, awsRestxml_deserializeOpErrorPutBucketIntelligentTieringConfiguration(response, &metadata) 9387 } 9388 output := &PutBucketIntelligentTieringConfigurationOutput{} 9389 out.Result = output 9390 9391 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9392 return out, metadata, &smithy.DeserializationError{ 9393 Err: fmt.Errorf("failed to discard response body, %w", err), 9394 } 9395 } 9396 9397 return out, metadata, err 9398} 9399 9400func awsRestxml_deserializeOpErrorPutBucketIntelligentTieringConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9401 var errorBuffer bytes.Buffer 9402 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9403 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9404 } 9405 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9406 9407 errorCode := "UnknownError" 9408 errorMessage := errorCode 9409 9410 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9411 UseStatusCode: true, StatusCode: response.StatusCode, 9412 }) 9413 if err != nil { 9414 return err 9415 } 9416 if hostID := errorComponents.HostID; len(hostID) != 0 { 9417 s3shared.SetHostIDMetadata(metadata, hostID) 9418 } 9419 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9420 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9421 } 9422 if len(errorComponents.Code) != 0 { 9423 errorCode = errorComponents.Code 9424 } 9425 if len(errorComponents.Message) != 0 { 9426 errorMessage = errorComponents.Message 9427 } 9428 errorBody.Seek(0, io.SeekStart) 9429 switch { 9430 default: 9431 genericError := &smithy.GenericAPIError{ 9432 Code: errorCode, 9433 Message: errorMessage, 9434 } 9435 return genericError 9436 9437 } 9438} 9439 9440type awsRestxml_deserializeOpPutBucketInventoryConfiguration struct { 9441} 9442 9443func (*awsRestxml_deserializeOpPutBucketInventoryConfiguration) ID() string { 9444 return "OperationDeserializer" 9445} 9446 9447func (m *awsRestxml_deserializeOpPutBucketInventoryConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9448 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9449) { 9450 out, metadata, err = next.HandleDeserialize(ctx, in) 9451 if err != nil { 9452 return out, metadata, err 9453 } 9454 9455 response, ok := out.RawResponse.(*smithyhttp.Response) 9456 if !ok { 9457 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9458 } 9459 9460 if response.StatusCode < 200 || response.StatusCode >= 300 { 9461 return out, metadata, awsRestxml_deserializeOpErrorPutBucketInventoryConfiguration(response, &metadata) 9462 } 9463 output := &PutBucketInventoryConfigurationOutput{} 9464 out.Result = output 9465 9466 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9467 return out, metadata, &smithy.DeserializationError{ 9468 Err: fmt.Errorf("failed to discard response body, %w", err), 9469 } 9470 } 9471 9472 return out, metadata, err 9473} 9474 9475func awsRestxml_deserializeOpErrorPutBucketInventoryConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9476 var errorBuffer bytes.Buffer 9477 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9478 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9479 } 9480 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9481 9482 errorCode := "UnknownError" 9483 errorMessage := errorCode 9484 9485 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9486 UseStatusCode: true, StatusCode: response.StatusCode, 9487 }) 9488 if err != nil { 9489 return err 9490 } 9491 if hostID := errorComponents.HostID; len(hostID) != 0 { 9492 s3shared.SetHostIDMetadata(metadata, hostID) 9493 } 9494 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9495 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9496 } 9497 if len(errorComponents.Code) != 0 { 9498 errorCode = errorComponents.Code 9499 } 9500 if len(errorComponents.Message) != 0 { 9501 errorMessage = errorComponents.Message 9502 } 9503 errorBody.Seek(0, io.SeekStart) 9504 switch { 9505 default: 9506 genericError := &smithy.GenericAPIError{ 9507 Code: errorCode, 9508 Message: errorMessage, 9509 } 9510 return genericError 9511 9512 } 9513} 9514 9515type awsRestxml_deserializeOpPutBucketLifecycleConfiguration struct { 9516} 9517 9518func (*awsRestxml_deserializeOpPutBucketLifecycleConfiguration) ID() string { 9519 return "OperationDeserializer" 9520} 9521 9522func (m *awsRestxml_deserializeOpPutBucketLifecycleConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9523 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9524) { 9525 out, metadata, err = next.HandleDeserialize(ctx, in) 9526 if err != nil { 9527 return out, metadata, err 9528 } 9529 9530 response, ok := out.RawResponse.(*smithyhttp.Response) 9531 if !ok { 9532 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9533 } 9534 9535 if response.StatusCode < 200 || response.StatusCode >= 300 { 9536 return out, metadata, awsRestxml_deserializeOpErrorPutBucketLifecycleConfiguration(response, &metadata) 9537 } 9538 output := &PutBucketLifecycleConfigurationOutput{} 9539 out.Result = output 9540 9541 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9542 return out, metadata, &smithy.DeserializationError{ 9543 Err: fmt.Errorf("failed to discard response body, %w", err), 9544 } 9545 } 9546 9547 return out, metadata, err 9548} 9549 9550func awsRestxml_deserializeOpErrorPutBucketLifecycleConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9551 var errorBuffer bytes.Buffer 9552 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9553 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9554 } 9555 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9556 9557 errorCode := "UnknownError" 9558 errorMessage := errorCode 9559 9560 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9561 UseStatusCode: true, StatusCode: response.StatusCode, 9562 }) 9563 if err != nil { 9564 return err 9565 } 9566 if hostID := errorComponents.HostID; len(hostID) != 0 { 9567 s3shared.SetHostIDMetadata(metadata, hostID) 9568 } 9569 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9570 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9571 } 9572 if len(errorComponents.Code) != 0 { 9573 errorCode = errorComponents.Code 9574 } 9575 if len(errorComponents.Message) != 0 { 9576 errorMessage = errorComponents.Message 9577 } 9578 errorBody.Seek(0, io.SeekStart) 9579 switch { 9580 default: 9581 genericError := &smithy.GenericAPIError{ 9582 Code: errorCode, 9583 Message: errorMessage, 9584 } 9585 return genericError 9586 9587 } 9588} 9589 9590type awsRestxml_deserializeOpPutBucketLogging struct { 9591} 9592 9593func (*awsRestxml_deserializeOpPutBucketLogging) ID() string { 9594 return "OperationDeserializer" 9595} 9596 9597func (m *awsRestxml_deserializeOpPutBucketLogging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9598 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9599) { 9600 out, metadata, err = next.HandleDeserialize(ctx, in) 9601 if err != nil { 9602 return out, metadata, err 9603 } 9604 9605 response, ok := out.RawResponse.(*smithyhttp.Response) 9606 if !ok { 9607 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9608 } 9609 9610 if response.StatusCode < 200 || response.StatusCode >= 300 { 9611 return out, metadata, awsRestxml_deserializeOpErrorPutBucketLogging(response, &metadata) 9612 } 9613 output := &PutBucketLoggingOutput{} 9614 out.Result = output 9615 9616 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9617 return out, metadata, &smithy.DeserializationError{ 9618 Err: fmt.Errorf("failed to discard response body, %w", err), 9619 } 9620 } 9621 9622 return out, metadata, err 9623} 9624 9625func awsRestxml_deserializeOpErrorPutBucketLogging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9626 var errorBuffer bytes.Buffer 9627 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9628 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9629 } 9630 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9631 9632 errorCode := "UnknownError" 9633 errorMessage := errorCode 9634 9635 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9636 UseStatusCode: true, StatusCode: response.StatusCode, 9637 }) 9638 if err != nil { 9639 return err 9640 } 9641 if hostID := errorComponents.HostID; len(hostID) != 0 { 9642 s3shared.SetHostIDMetadata(metadata, hostID) 9643 } 9644 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9645 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9646 } 9647 if len(errorComponents.Code) != 0 { 9648 errorCode = errorComponents.Code 9649 } 9650 if len(errorComponents.Message) != 0 { 9651 errorMessage = errorComponents.Message 9652 } 9653 errorBody.Seek(0, io.SeekStart) 9654 switch { 9655 default: 9656 genericError := &smithy.GenericAPIError{ 9657 Code: errorCode, 9658 Message: errorMessage, 9659 } 9660 return genericError 9661 9662 } 9663} 9664 9665type awsRestxml_deserializeOpPutBucketMetricsConfiguration struct { 9666} 9667 9668func (*awsRestxml_deserializeOpPutBucketMetricsConfiguration) ID() string { 9669 return "OperationDeserializer" 9670} 9671 9672func (m *awsRestxml_deserializeOpPutBucketMetricsConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9673 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9674) { 9675 out, metadata, err = next.HandleDeserialize(ctx, in) 9676 if err != nil { 9677 return out, metadata, err 9678 } 9679 9680 response, ok := out.RawResponse.(*smithyhttp.Response) 9681 if !ok { 9682 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9683 } 9684 9685 if response.StatusCode < 200 || response.StatusCode >= 300 { 9686 return out, metadata, awsRestxml_deserializeOpErrorPutBucketMetricsConfiguration(response, &metadata) 9687 } 9688 output := &PutBucketMetricsConfigurationOutput{} 9689 out.Result = output 9690 9691 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9692 return out, metadata, &smithy.DeserializationError{ 9693 Err: fmt.Errorf("failed to discard response body, %w", err), 9694 } 9695 } 9696 9697 return out, metadata, err 9698} 9699 9700func awsRestxml_deserializeOpErrorPutBucketMetricsConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9701 var errorBuffer bytes.Buffer 9702 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9703 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9704 } 9705 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9706 9707 errorCode := "UnknownError" 9708 errorMessage := errorCode 9709 9710 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9711 UseStatusCode: true, StatusCode: response.StatusCode, 9712 }) 9713 if err != nil { 9714 return err 9715 } 9716 if hostID := errorComponents.HostID; len(hostID) != 0 { 9717 s3shared.SetHostIDMetadata(metadata, hostID) 9718 } 9719 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9720 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9721 } 9722 if len(errorComponents.Code) != 0 { 9723 errorCode = errorComponents.Code 9724 } 9725 if len(errorComponents.Message) != 0 { 9726 errorMessage = errorComponents.Message 9727 } 9728 errorBody.Seek(0, io.SeekStart) 9729 switch { 9730 default: 9731 genericError := &smithy.GenericAPIError{ 9732 Code: errorCode, 9733 Message: errorMessage, 9734 } 9735 return genericError 9736 9737 } 9738} 9739 9740type awsRestxml_deserializeOpPutBucketNotificationConfiguration struct { 9741} 9742 9743func (*awsRestxml_deserializeOpPutBucketNotificationConfiguration) ID() string { 9744 return "OperationDeserializer" 9745} 9746 9747func (m *awsRestxml_deserializeOpPutBucketNotificationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9748 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9749) { 9750 out, metadata, err = next.HandleDeserialize(ctx, in) 9751 if err != nil { 9752 return out, metadata, err 9753 } 9754 9755 response, ok := out.RawResponse.(*smithyhttp.Response) 9756 if !ok { 9757 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9758 } 9759 9760 if response.StatusCode < 200 || response.StatusCode >= 300 { 9761 return out, metadata, awsRestxml_deserializeOpErrorPutBucketNotificationConfiguration(response, &metadata) 9762 } 9763 output := &PutBucketNotificationConfigurationOutput{} 9764 out.Result = output 9765 9766 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9767 return out, metadata, &smithy.DeserializationError{ 9768 Err: fmt.Errorf("failed to discard response body, %w", err), 9769 } 9770 } 9771 9772 return out, metadata, err 9773} 9774 9775func awsRestxml_deserializeOpErrorPutBucketNotificationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9776 var errorBuffer bytes.Buffer 9777 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9778 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9779 } 9780 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9781 9782 errorCode := "UnknownError" 9783 errorMessage := errorCode 9784 9785 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9786 UseStatusCode: true, StatusCode: response.StatusCode, 9787 }) 9788 if err != nil { 9789 return err 9790 } 9791 if hostID := errorComponents.HostID; len(hostID) != 0 { 9792 s3shared.SetHostIDMetadata(metadata, hostID) 9793 } 9794 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9795 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9796 } 9797 if len(errorComponents.Code) != 0 { 9798 errorCode = errorComponents.Code 9799 } 9800 if len(errorComponents.Message) != 0 { 9801 errorMessage = errorComponents.Message 9802 } 9803 errorBody.Seek(0, io.SeekStart) 9804 switch { 9805 default: 9806 genericError := &smithy.GenericAPIError{ 9807 Code: errorCode, 9808 Message: errorMessage, 9809 } 9810 return genericError 9811 9812 } 9813} 9814 9815type awsRestxml_deserializeOpPutBucketOwnershipControls struct { 9816} 9817 9818func (*awsRestxml_deserializeOpPutBucketOwnershipControls) ID() string { 9819 return "OperationDeserializer" 9820} 9821 9822func (m *awsRestxml_deserializeOpPutBucketOwnershipControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9823 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9824) { 9825 out, metadata, err = next.HandleDeserialize(ctx, in) 9826 if err != nil { 9827 return out, metadata, err 9828 } 9829 9830 response, ok := out.RawResponse.(*smithyhttp.Response) 9831 if !ok { 9832 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9833 } 9834 9835 if response.StatusCode < 200 || response.StatusCode >= 300 { 9836 return out, metadata, awsRestxml_deserializeOpErrorPutBucketOwnershipControls(response, &metadata) 9837 } 9838 output := &PutBucketOwnershipControlsOutput{} 9839 out.Result = output 9840 9841 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9842 return out, metadata, &smithy.DeserializationError{ 9843 Err: fmt.Errorf("failed to discard response body, %w", err), 9844 } 9845 } 9846 9847 return out, metadata, err 9848} 9849 9850func awsRestxml_deserializeOpErrorPutBucketOwnershipControls(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9851 var errorBuffer bytes.Buffer 9852 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9853 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9854 } 9855 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9856 9857 errorCode := "UnknownError" 9858 errorMessage := errorCode 9859 9860 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9861 UseStatusCode: true, StatusCode: response.StatusCode, 9862 }) 9863 if err != nil { 9864 return err 9865 } 9866 if hostID := errorComponents.HostID; len(hostID) != 0 { 9867 s3shared.SetHostIDMetadata(metadata, hostID) 9868 } 9869 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9870 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9871 } 9872 if len(errorComponents.Code) != 0 { 9873 errorCode = errorComponents.Code 9874 } 9875 if len(errorComponents.Message) != 0 { 9876 errorMessage = errorComponents.Message 9877 } 9878 errorBody.Seek(0, io.SeekStart) 9879 switch { 9880 default: 9881 genericError := &smithy.GenericAPIError{ 9882 Code: errorCode, 9883 Message: errorMessage, 9884 } 9885 return genericError 9886 9887 } 9888} 9889 9890type awsRestxml_deserializeOpPutBucketPolicy struct { 9891} 9892 9893func (*awsRestxml_deserializeOpPutBucketPolicy) ID() string { 9894 return "OperationDeserializer" 9895} 9896 9897func (m *awsRestxml_deserializeOpPutBucketPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9898 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9899) { 9900 out, metadata, err = next.HandleDeserialize(ctx, in) 9901 if err != nil { 9902 return out, metadata, err 9903 } 9904 9905 response, ok := out.RawResponse.(*smithyhttp.Response) 9906 if !ok { 9907 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9908 } 9909 9910 if response.StatusCode < 200 || response.StatusCode >= 300 { 9911 return out, metadata, awsRestxml_deserializeOpErrorPutBucketPolicy(response, &metadata) 9912 } 9913 output := &PutBucketPolicyOutput{} 9914 out.Result = output 9915 9916 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9917 return out, metadata, &smithy.DeserializationError{ 9918 Err: fmt.Errorf("failed to discard response body, %w", err), 9919 } 9920 } 9921 9922 return out, metadata, err 9923} 9924 9925func awsRestxml_deserializeOpErrorPutBucketPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9926 var errorBuffer bytes.Buffer 9927 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9928 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9929 } 9930 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9931 9932 errorCode := "UnknownError" 9933 errorMessage := errorCode 9934 9935 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 9936 UseStatusCode: true, StatusCode: response.StatusCode, 9937 }) 9938 if err != nil { 9939 return err 9940 } 9941 if hostID := errorComponents.HostID; len(hostID) != 0 { 9942 s3shared.SetHostIDMetadata(metadata, hostID) 9943 } 9944 if reqID := errorComponents.RequestID; len(reqID) != 0 { 9945 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 9946 } 9947 if len(errorComponents.Code) != 0 { 9948 errorCode = errorComponents.Code 9949 } 9950 if len(errorComponents.Message) != 0 { 9951 errorMessage = errorComponents.Message 9952 } 9953 errorBody.Seek(0, io.SeekStart) 9954 switch { 9955 default: 9956 genericError := &smithy.GenericAPIError{ 9957 Code: errorCode, 9958 Message: errorMessage, 9959 } 9960 return genericError 9961 9962 } 9963} 9964 9965type awsRestxml_deserializeOpPutBucketReplication struct { 9966} 9967 9968func (*awsRestxml_deserializeOpPutBucketReplication) ID() string { 9969 return "OperationDeserializer" 9970} 9971 9972func (m *awsRestxml_deserializeOpPutBucketReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9973 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9974) { 9975 out, metadata, err = next.HandleDeserialize(ctx, in) 9976 if err != nil { 9977 return out, metadata, err 9978 } 9979 9980 response, ok := out.RawResponse.(*smithyhttp.Response) 9981 if !ok { 9982 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9983 } 9984 9985 if response.StatusCode < 200 || response.StatusCode >= 300 { 9986 return out, metadata, awsRestxml_deserializeOpErrorPutBucketReplication(response, &metadata) 9987 } 9988 output := &PutBucketReplicationOutput{} 9989 out.Result = output 9990 9991 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 9992 return out, metadata, &smithy.DeserializationError{ 9993 Err: fmt.Errorf("failed to discard response body, %w", err), 9994 } 9995 } 9996 9997 return out, metadata, err 9998} 9999 10000func awsRestxml_deserializeOpErrorPutBucketReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10001 var errorBuffer bytes.Buffer 10002 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10003 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10004 } 10005 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10006 10007 errorCode := "UnknownError" 10008 errorMessage := errorCode 10009 10010 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10011 UseStatusCode: true, StatusCode: response.StatusCode, 10012 }) 10013 if err != nil { 10014 return err 10015 } 10016 if hostID := errorComponents.HostID; len(hostID) != 0 { 10017 s3shared.SetHostIDMetadata(metadata, hostID) 10018 } 10019 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10020 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10021 } 10022 if len(errorComponents.Code) != 0 { 10023 errorCode = errorComponents.Code 10024 } 10025 if len(errorComponents.Message) != 0 { 10026 errorMessage = errorComponents.Message 10027 } 10028 errorBody.Seek(0, io.SeekStart) 10029 switch { 10030 default: 10031 genericError := &smithy.GenericAPIError{ 10032 Code: errorCode, 10033 Message: errorMessage, 10034 } 10035 return genericError 10036 10037 } 10038} 10039 10040type awsRestxml_deserializeOpPutBucketRequestPayment struct { 10041} 10042 10043func (*awsRestxml_deserializeOpPutBucketRequestPayment) ID() string { 10044 return "OperationDeserializer" 10045} 10046 10047func (m *awsRestxml_deserializeOpPutBucketRequestPayment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10048 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10049) { 10050 out, metadata, err = next.HandleDeserialize(ctx, in) 10051 if err != nil { 10052 return out, metadata, err 10053 } 10054 10055 response, ok := out.RawResponse.(*smithyhttp.Response) 10056 if !ok { 10057 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10058 } 10059 10060 if response.StatusCode < 200 || response.StatusCode >= 300 { 10061 return out, metadata, awsRestxml_deserializeOpErrorPutBucketRequestPayment(response, &metadata) 10062 } 10063 output := &PutBucketRequestPaymentOutput{} 10064 out.Result = output 10065 10066 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10067 return out, metadata, &smithy.DeserializationError{ 10068 Err: fmt.Errorf("failed to discard response body, %w", err), 10069 } 10070 } 10071 10072 return out, metadata, err 10073} 10074 10075func awsRestxml_deserializeOpErrorPutBucketRequestPayment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10076 var errorBuffer bytes.Buffer 10077 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10078 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10079 } 10080 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10081 10082 errorCode := "UnknownError" 10083 errorMessage := errorCode 10084 10085 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10086 UseStatusCode: true, StatusCode: response.StatusCode, 10087 }) 10088 if err != nil { 10089 return err 10090 } 10091 if hostID := errorComponents.HostID; len(hostID) != 0 { 10092 s3shared.SetHostIDMetadata(metadata, hostID) 10093 } 10094 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10095 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10096 } 10097 if len(errorComponents.Code) != 0 { 10098 errorCode = errorComponents.Code 10099 } 10100 if len(errorComponents.Message) != 0 { 10101 errorMessage = errorComponents.Message 10102 } 10103 errorBody.Seek(0, io.SeekStart) 10104 switch { 10105 default: 10106 genericError := &smithy.GenericAPIError{ 10107 Code: errorCode, 10108 Message: errorMessage, 10109 } 10110 return genericError 10111 10112 } 10113} 10114 10115type awsRestxml_deserializeOpPutBucketTagging struct { 10116} 10117 10118func (*awsRestxml_deserializeOpPutBucketTagging) ID() string { 10119 return "OperationDeserializer" 10120} 10121 10122func (m *awsRestxml_deserializeOpPutBucketTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10123 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10124) { 10125 out, metadata, err = next.HandleDeserialize(ctx, in) 10126 if err != nil { 10127 return out, metadata, err 10128 } 10129 10130 response, ok := out.RawResponse.(*smithyhttp.Response) 10131 if !ok { 10132 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10133 } 10134 10135 if response.StatusCode < 200 || response.StatusCode >= 300 { 10136 return out, metadata, awsRestxml_deserializeOpErrorPutBucketTagging(response, &metadata) 10137 } 10138 output := &PutBucketTaggingOutput{} 10139 out.Result = output 10140 10141 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10142 return out, metadata, &smithy.DeserializationError{ 10143 Err: fmt.Errorf("failed to discard response body, %w", err), 10144 } 10145 } 10146 10147 return out, metadata, err 10148} 10149 10150func awsRestxml_deserializeOpErrorPutBucketTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10151 var errorBuffer bytes.Buffer 10152 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10153 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10154 } 10155 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10156 10157 errorCode := "UnknownError" 10158 errorMessage := errorCode 10159 10160 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10161 UseStatusCode: true, StatusCode: response.StatusCode, 10162 }) 10163 if err != nil { 10164 return err 10165 } 10166 if hostID := errorComponents.HostID; len(hostID) != 0 { 10167 s3shared.SetHostIDMetadata(metadata, hostID) 10168 } 10169 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10170 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10171 } 10172 if len(errorComponents.Code) != 0 { 10173 errorCode = errorComponents.Code 10174 } 10175 if len(errorComponents.Message) != 0 { 10176 errorMessage = errorComponents.Message 10177 } 10178 errorBody.Seek(0, io.SeekStart) 10179 switch { 10180 default: 10181 genericError := &smithy.GenericAPIError{ 10182 Code: errorCode, 10183 Message: errorMessage, 10184 } 10185 return genericError 10186 10187 } 10188} 10189 10190type awsRestxml_deserializeOpPutBucketVersioning struct { 10191} 10192 10193func (*awsRestxml_deserializeOpPutBucketVersioning) ID() string { 10194 return "OperationDeserializer" 10195} 10196 10197func (m *awsRestxml_deserializeOpPutBucketVersioning) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10198 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10199) { 10200 out, metadata, err = next.HandleDeserialize(ctx, in) 10201 if err != nil { 10202 return out, metadata, err 10203 } 10204 10205 response, ok := out.RawResponse.(*smithyhttp.Response) 10206 if !ok { 10207 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10208 } 10209 10210 if response.StatusCode < 200 || response.StatusCode >= 300 { 10211 return out, metadata, awsRestxml_deserializeOpErrorPutBucketVersioning(response, &metadata) 10212 } 10213 output := &PutBucketVersioningOutput{} 10214 out.Result = output 10215 10216 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10217 return out, metadata, &smithy.DeserializationError{ 10218 Err: fmt.Errorf("failed to discard response body, %w", err), 10219 } 10220 } 10221 10222 return out, metadata, err 10223} 10224 10225func awsRestxml_deserializeOpErrorPutBucketVersioning(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10226 var errorBuffer bytes.Buffer 10227 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10228 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10229 } 10230 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10231 10232 errorCode := "UnknownError" 10233 errorMessage := errorCode 10234 10235 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10236 UseStatusCode: true, StatusCode: response.StatusCode, 10237 }) 10238 if err != nil { 10239 return err 10240 } 10241 if hostID := errorComponents.HostID; len(hostID) != 0 { 10242 s3shared.SetHostIDMetadata(metadata, hostID) 10243 } 10244 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10245 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10246 } 10247 if len(errorComponents.Code) != 0 { 10248 errorCode = errorComponents.Code 10249 } 10250 if len(errorComponents.Message) != 0 { 10251 errorMessage = errorComponents.Message 10252 } 10253 errorBody.Seek(0, io.SeekStart) 10254 switch { 10255 default: 10256 genericError := &smithy.GenericAPIError{ 10257 Code: errorCode, 10258 Message: errorMessage, 10259 } 10260 return genericError 10261 10262 } 10263} 10264 10265type awsRestxml_deserializeOpPutBucketWebsite struct { 10266} 10267 10268func (*awsRestxml_deserializeOpPutBucketWebsite) ID() string { 10269 return "OperationDeserializer" 10270} 10271 10272func (m *awsRestxml_deserializeOpPutBucketWebsite) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10273 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10274) { 10275 out, metadata, err = next.HandleDeserialize(ctx, in) 10276 if err != nil { 10277 return out, metadata, err 10278 } 10279 10280 response, ok := out.RawResponse.(*smithyhttp.Response) 10281 if !ok { 10282 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10283 } 10284 10285 if response.StatusCode < 200 || response.StatusCode >= 300 { 10286 return out, metadata, awsRestxml_deserializeOpErrorPutBucketWebsite(response, &metadata) 10287 } 10288 output := &PutBucketWebsiteOutput{} 10289 out.Result = output 10290 10291 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10292 return out, metadata, &smithy.DeserializationError{ 10293 Err: fmt.Errorf("failed to discard response body, %w", err), 10294 } 10295 } 10296 10297 return out, metadata, err 10298} 10299 10300func awsRestxml_deserializeOpErrorPutBucketWebsite(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10301 var errorBuffer bytes.Buffer 10302 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10303 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10304 } 10305 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10306 10307 errorCode := "UnknownError" 10308 errorMessage := errorCode 10309 10310 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10311 UseStatusCode: true, StatusCode: response.StatusCode, 10312 }) 10313 if err != nil { 10314 return err 10315 } 10316 if hostID := errorComponents.HostID; len(hostID) != 0 { 10317 s3shared.SetHostIDMetadata(metadata, hostID) 10318 } 10319 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10320 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10321 } 10322 if len(errorComponents.Code) != 0 { 10323 errorCode = errorComponents.Code 10324 } 10325 if len(errorComponents.Message) != 0 { 10326 errorMessage = errorComponents.Message 10327 } 10328 errorBody.Seek(0, io.SeekStart) 10329 switch { 10330 default: 10331 genericError := &smithy.GenericAPIError{ 10332 Code: errorCode, 10333 Message: errorMessage, 10334 } 10335 return genericError 10336 10337 } 10338} 10339 10340type awsRestxml_deserializeOpPutObject struct { 10341} 10342 10343func (*awsRestxml_deserializeOpPutObject) ID() string { 10344 return "OperationDeserializer" 10345} 10346 10347func (m *awsRestxml_deserializeOpPutObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10348 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10349) { 10350 out, metadata, err = next.HandleDeserialize(ctx, in) 10351 if err != nil { 10352 return out, metadata, err 10353 } 10354 10355 response, ok := out.RawResponse.(*smithyhttp.Response) 10356 if !ok { 10357 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10358 } 10359 10360 if response.StatusCode < 200 || response.StatusCode >= 300 { 10361 return out, metadata, awsRestxml_deserializeOpErrorPutObject(response, &metadata) 10362 } 10363 output := &PutObjectOutput{} 10364 out.Result = output 10365 10366 err = awsRestxml_deserializeOpHttpBindingsPutObjectOutput(output, response) 10367 if err != nil { 10368 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10369 } 10370 10371 return out, metadata, err 10372} 10373 10374func awsRestxml_deserializeOpErrorPutObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10375 var errorBuffer bytes.Buffer 10376 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10377 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10378 } 10379 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10380 10381 errorCode := "UnknownError" 10382 errorMessage := errorCode 10383 10384 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10385 UseStatusCode: true, StatusCode: response.StatusCode, 10386 }) 10387 if err != nil { 10388 return err 10389 } 10390 if hostID := errorComponents.HostID; len(hostID) != 0 { 10391 s3shared.SetHostIDMetadata(metadata, hostID) 10392 } 10393 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10394 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10395 } 10396 if len(errorComponents.Code) != 0 { 10397 errorCode = errorComponents.Code 10398 } 10399 if len(errorComponents.Message) != 0 { 10400 errorMessage = errorComponents.Message 10401 } 10402 errorBody.Seek(0, io.SeekStart) 10403 switch { 10404 default: 10405 genericError := &smithy.GenericAPIError{ 10406 Code: errorCode, 10407 Message: errorMessage, 10408 } 10409 return genericError 10410 10411 } 10412} 10413 10414func awsRestxml_deserializeOpHttpBindingsPutObjectOutput(v *PutObjectOutput, response *smithyhttp.Response) error { 10415 if v == nil { 10416 return fmt.Errorf("unsupported deserialization for nil %T", v) 10417 } 10418 10419 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 10420 headerValues[0] = strings.TrimSpace(headerValues[0]) 10421 vv, err := strconv.ParseBool(headerValues[0]) 10422 if err != nil { 10423 return err 10424 } 10425 v.BucketKeyEnabled = vv 10426 } 10427 10428 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 10429 headerValues[0] = strings.TrimSpace(headerValues[0]) 10430 v.ETag = ptr.String(headerValues[0]) 10431 } 10432 10433 if headerValues := response.Header.Values("x-amz-expiration"); len(headerValues) != 0 { 10434 headerValues[0] = strings.TrimSpace(headerValues[0]) 10435 v.Expiration = ptr.String(headerValues[0]) 10436 } 10437 10438 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10439 headerValues[0] = strings.TrimSpace(headerValues[0]) 10440 v.RequestCharged = types.RequestCharged(headerValues[0]) 10441 } 10442 10443 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 10444 headerValues[0] = strings.TrimSpace(headerValues[0]) 10445 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 10446 } 10447 10448 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 10449 headerValues[0] = strings.TrimSpace(headerValues[0]) 10450 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 10451 } 10452 10453 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 10454 headerValues[0] = strings.TrimSpace(headerValues[0]) 10455 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 10456 } 10457 10458 if headerValues := response.Header.Values("x-amz-server-side-encryption-context"); len(headerValues) != 0 { 10459 headerValues[0] = strings.TrimSpace(headerValues[0]) 10460 v.SSEKMSEncryptionContext = ptr.String(headerValues[0]) 10461 } 10462 10463 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 10464 headerValues[0] = strings.TrimSpace(headerValues[0]) 10465 v.SSEKMSKeyId = ptr.String(headerValues[0]) 10466 } 10467 10468 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 10469 headerValues[0] = strings.TrimSpace(headerValues[0]) 10470 v.VersionId = ptr.String(headerValues[0]) 10471 } 10472 10473 return nil 10474} 10475 10476type awsRestxml_deserializeOpPutObjectAcl struct { 10477} 10478 10479func (*awsRestxml_deserializeOpPutObjectAcl) ID() string { 10480 return "OperationDeserializer" 10481} 10482 10483func (m *awsRestxml_deserializeOpPutObjectAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10484 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10485) { 10486 out, metadata, err = next.HandleDeserialize(ctx, in) 10487 if err != nil { 10488 return out, metadata, err 10489 } 10490 10491 response, ok := out.RawResponse.(*smithyhttp.Response) 10492 if !ok { 10493 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10494 } 10495 10496 if response.StatusCode < 200 || response.StatusCode >= 300 { 10497 return out, metadata, awsRestxml_deserializeOpErrorPutObjectAcl(response, &metadata) 10498 } 10499 output := &PutObjectAclOutput{} 10500 out.Result = output 10501 10502 err = awsRestxml_deserializeOpHttpBindingsPutObjectAclOutput(output, response) 10503 if err != nil { 10504 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10505 } 10506 10507 return out, metadata, err 10508} 10509 10510func awsRestxml_deserializeOpErrorPutObjectAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10511 var errorBuffer bytes.Buffer 10512 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10513 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10514 } 10515 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10516 10517 errorCode := "UnknownError" 10518 errorMessage := errorCode 10519 10520 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10521 UseStatusCode: true, StatusCode: response.StatusCode, 10522 }) 10523 if err != nil { 10524 return err 10525 } 10526 if hostID := errorComponents.HostID; len(hostID) != 0 { 10527 s3shared.SetHostIDMetadata(metadata, hostID) 10528 } 10529 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10530 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10531 } 10532 if len(errorComponents.Code) != 0 { 10533 errorCode = errorComponents.Code 10534 } 10535 if len(errorComponents.Message) != 0 { 10536 errorMessage = errorComponents.Message 10537 } 10538 errorBody.Seek(0, io.SeekStart) 10539 switch { 10540 case strings.EqualFold("NoSuchKey", errorCode): 10541 return awsRestxml_deserializeErrorNoSuchKey(response, errorBody) 10542 10543 default: 10544 genericError := &smithy.GenericAPIError{ 10545 Code: errorCode, 10546 Message: errorMessage, 10547 } 10548 return genericError 10549 10550 } 10551} 10552 10553func awsRestxml_deserializeOpHttpBindingsPutObjectAclOutput(v *PutObjectAclOutput, response *smithyhttp.Response) error { 10554 if v == nil { 10555 return fmt.Errorf("unsupported deserialization for nil %T", v) 10556 } 10557 10558 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10559 headerValues[0] = strings.TrimSpace(headerValues[0]) 10560 v.RequestCharged = types.RequestCharged(headerValues[0]) 10561 } 10562 10563 return nil 10564} 10565 10566type awsRestxml_deserializeOpPutObjectLegalHold struct { 10567} 10568 10569func (*awsRestxml_deserializeOpPutObjectLegalHold) ID() string { 10570 return "OperationDeserializer" 10571} 10572 10573func (m *awsRestxml_deserializeOpPutObjectLegalHold) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10574 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10575) { 10576 out, metadata, err = next.HandleDeserialize(ctx, in) 10577 if err != nil { 10578 return out, metadata, err 10579 } 10580 10581 response, ok := out.RawResponse.(*smithyhttp.Response) 10582 if !ok { 10583 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10584 } 10585 10586 if response.StatusCode < 200 || response.StatusCode >= 300 { 10587 return out, metadata, awsRestxml_deserializeOpErrorPutObjectLegalHold(response, &metadata) 10588 } 10589 output := &PutObjectLegalHoldOutput{} 10590 out.Result = output 10591 10592 err = awsRestxml_deserializeOpHttpBindingsPutObjectLegalHoldOutput(output, response) 10593 if err != nil { 10594 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10595 } 10596 10597 return out, metadata, err 10598} 10599 10600func awsRestxml_deserializeOpErrorPutObjectLegalHold(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10601 var errorBuffer bytes.Buffer 10602 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10603 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10604 } 10605 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10606 10607 errorCode := "UnknownError" 10608 errorMessage := errorCode 10609 10610 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10611 UseStatusCode: true, StatusCode: response.StatusCode, 10612 }) 10613 if err != nil { 10614 return err 10615 } 10616 if hostID := errorComponents.HostID; len(hostID) != 0 { 10617 s3shared.SetHostIDMetadata(metadata, hostID) 10618 } 10619 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10620 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10621 } 10622 if len(errorComponents.Code) != 0 { 10623 errorCode = errorComponents.Code 10624 } 10625 if len(errorComponents.Message) != 0 { 10626 errorMessage = errorComponents.Message 10627 } 10628 errorBody.Seek(0, io.SeekStart) 10629 switch { 10630 default: 10631 genericError := &smithy.GenericAPIError{ 10632 Code: errorCode, 10633 Message: errorMessage, 10634 } 10635 return genericError 10636 10637 } 10638} 10639 10640func awsRestxml_deserializeOpHttpBindingsPutObjectLegalHoldOutput(v *PutObjectLegalHoldOutput, response *smithyhttp.Response) error { 10641 if v == nil { 10642 return fmt.Errorf("unsupported deserialization for nil %T", v) 10643 } 10644 10645 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10646 headerValues[0] = strings.TrimSpace(headerValues[0]) 10647 v.RequestCharged = types.RequestCharged(headerValues[0]) 10648 } 10649 10650 return nil 10651} 10652 10653type awsRestxml_deserializeOpPutObjectLockConfiguration struct { 10654} 10655 10656func (*awsRestxml_deserializeOpPutObjectLockConfiguration) ID() string { 10657 return "OperationDeserializer" 10658} 10659 10660func (m *awsRestxml_deserializeOpPutObjectLockConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10661 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10662) { 10663 out, metadata, err = next.HandleDeserialize(ctx, in) 10664 if err != nil { 10665 return out, metadata, err 10666 } 10667 10668 response, ok := out.RawResponse.(*smithyhttp.Response) 10669 if !ok { 10670 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10671 } 10672 10673 if response.StatusCode < 200 || response.StatusCode >= 300 { 10674 return out, metadata, awsRestxml_deserializeOpErrorPutObjectLockConfiguration(response, &metadata) 10675 } 10676 output := &PutObjectLockConfigurationOutput{} 10677 out.Result = output 10678 10679 err = awsRestxml_deserializeOpHttpBindingsPutObjectLockConfigurationOutput(output, response) 10680 if err != nil { 10681 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10682 } 10683 10684 return out, metadata, err 10685} 10686 10687func awsRestxml_deserializeOpErrorPutObjectLockConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10688 var errorBuffer bytes.Buffer 10689 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10690 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10691 } 10692 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10693 10694 errorCode := "UnknownError" 10695 errorMessage := errorCode 10696 10697 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10698 UseStatusCode: true, StatusCode: response.StatusCode, 10699 }) 10700 if err != nil { 10701 return err 10702 } 10703 if hostID := errorComponents.HostID; len(hostID) != 0 { 10704 s3shared.SetHostIDMetadata(metadata, hostID) 10705 } 10706 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10707 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10708 } 10709 if len(errorComponents.Code) != 0 { 10710 errorCode = errorComponents.Code 10711 } 10712 if len(errorComponents.Message) != 0 { 10713 errorMessage = errorComponents.Message 10714 } 10715 errorBody.Seek(0, io.SeekStart) 10716 switch { 10717 default: 10718 genericError := &smithy.GenericAPIError{ 10719 Code: errorCode, 10720 Message: errorMessage, 10721 } 10722 return genericError 10723 10724 } 10725} 10726 10727func awsRestxml_deserializeOpHttpBindingsPutObjectLockConfigurationOutput(v *PutObjectLockConfigurationOutput, response *smithyhttp.Response) error { 10728 if v == nil { 10729 return fmt.Errorf("unsupported deserialization for nil %T", v) 10730 } 10731 10732 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10733 headerValues[0] = strings.TrimSpace(headerValues[0]) 10734 v.RequestCharged = types.RequestCharged(headerValues[0]) 10735 } 10736 10737 return nil 10738} 10739 10740type awsRestxml_deserializeOpPutObjectRetention struct { 10741} 10742 10743func (*awsRestxml_deserializeOpPutObjectRetention) ID() string { 10744 return "OperationDeserializer" 10745} 10746 10747func (m *awsRestxml_deserializeOpPutObjectRetention) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10748 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10749) { 10750 out, metadata, err = next.HandleDeserialize(ctx, in) 10751 if err != nil { 10752 return out, metadata, err 10753 } 10754 10755 response, ok := out.RawResponse.(*smithyhttp.Response) 10756 if !ok { 10757 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10758 } 10759 10760 if response.StatusCode < 200 || response.StatusCode >= 300 { 10761 return out, metadata, awsRestxml_deserializeOpErrorPutObjectRetention(response, &metadata) 10762 } 10763 output := &PutObjectRetentionOutput{} 10764 out.Result = output 10765 10766 err = awsRestxml_deserializeOpHttpBindingsPutObjectRetentionOutput(output, response) 10767 if err != nil { 10768 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10769 } 10770 10771 return out, metadata, err 10772} 10773 10774func awsRestxml_deserializeOpErrorPutObjectRetention(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10775 var errorBuffer bytes.Buffer 10776 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10777 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10778 } 10779 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10780 10781 errorCode := "UnknownError" 10782 errorMessage := errorCode 10783 10784 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10785 UseStatusCode: true, StatusCode: response.StatusCode, 10786 }) 10787 if err != nil { 10788 return err 10789 } 10790 if hostID := errorComponents.HostID; len(hostID) != 0 { 10791 s3shared.SetHostIDMetadata(metadata, hostID) 10792 } 10793 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10794 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10795 } 10796 if len(errorComponents.Code) != 0 { 10797 errorCode = errorComponents.Code 10798 } 10799 if len(errorComponents.Message) != 0 { 10800 errorMessage = errorComponents.Message 10801 } 10802 errorBody.Seek(0, io.SeekStart) 10803 switch { 10804 default: 10805 genericError := &smithy.GenericAPIError{ 10806 Code: errorCode, 10807 Message: errorMessage, 10808 } 10809 return genericError 10810 10811 } 10812} 10813 10814func awsRestxml_deserializeOpHttpBindingsPutObjectRetentionOutput(v *PutObjectRetentionOutput, response *smithyhttp.Response) error { 10815 if v == nil { 10816 return fmt.Errorf("unsupported deserialization for nil %T", v) 10817 } 10818 10819 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 10820 headerValues[0] = strings.TrimSpace(headerValues[0]) 10821 v.RequestCharged = types.RequestCharged(headerValues[0]) 10822 } 10823 10824 return nil 10825} 10826 10827type awsRestxml_deserializeOpPutObjectTagging struct { 10828} 10829 10830func (*awsRestxml_deserializeOpPutObjectTagging) ID() string { 10831 return "OperationDeserializer" 10832} 10833 10834func (m *awsRestxml_deserializeOpPutObjectTagging) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10835 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10836) { 10837 out, metadata, err = next.HandleDeserialize(ctx, in) 10838 if err != nil { 10839 return out, metadata, err 10840 } 10841 10842 response, ok := out.RawResponse.(*smithyhttp.Response) 10843 if !ok { 10844 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10845 } 10846 10847 if response.StatusCode < 200 || response.StatusCode >= 300 { 10848 return out, metadata, awsRestxml_deserializeOpErrorPutObjectTagging(response, &metadata) 10849 } 10850 output := &PutObjectTaggingOutput{} 10851 out.Result = output 10852 10853 err = awsRestxml_deserializeOpHttpBindingsPutObjectTaggingOutput(output, response) 10854 if err != nil { 10855 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 10856 } 10857 10858 return out, metadata, err 10859} 10860 10861func awsRestxml_deserializeOpErrorPutObjectTagging(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10862 var errorBuffer bytes.Buffer 10863 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10864 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10865 } 10866 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10867 10868 errorCode := "UnknownError" 10869 errorMessage := errorCode 10870 10871 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10872 UseStatusCode: true, StatusCode: response.StatusCode, 10873 }) 10874 if err != nil { 10875 return err 10876 } 10877 if hostID := errorComponents.HostID; len(hostID) != 0 { 10878 s3shared.SetHostIDMetadata(metadata, hostID) 10879 } 10880 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10881 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10882 } 10883 if len(errorComponents.Code) != 0 { 10884 errorCode = errorComponents.Code 10885 } 10886 if len(errorComponents.Message) != 0 { 10887 errorMessage = errorComponents.Message 10888 } 10889 errorBody.Seek(0, io.SeekStart) 10890 switch { 10891 default: 10892 genericError := &smithy.GenericAPIError{ 10893 Code: errorCode, 10894 Message: errorMessage, 10895 } 10896 return genericError 10897 10898 } 10899} 10900 10901func awsRestxml_deserializeOpHttpBindingsPutObjectTaggingOutput(v *PutObjectTaggingOutput, response *smithyhttp.Response) error { 10902 if v == nil { 10903 return fmt.Errorf("unsupported deserialization for nil %T", v) 10904 } 10905 10906 if headerValues := response.Header.Values("x-amz-version-id"); len(headerValues) != 0 { 10907 headerValues[0] = strings.TrimSpace(headerValues[0]) 10908 v.VersionId = ptr.String(headerValues[0]) 10909 } 10910 10911 return nil 10912} 10913 10914type awsRestxml_deserializeOpPutPublicAccessBlock struct { 10915} 10916 10917func (*awsRestxml_deserializeOpPutPublicAccessBlock) ID() string { 10918 return "OperationDeserializer" 10919} 10920 10921func (m *awsRestxml_deserializeOpPutPublicAccessBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10922 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10923) { 10924 out, metadata, err = next.HandleDeserialize(ctx, in) 10925 if err != nil { 10926 return out, metadata, err 10927 } 10928 10929 response, ok := out.RawResponse.(*smithyhttp.Response) 10930 if !ok { 10931 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10932 } 10933 10934 if response.StatusCode < 200 || response.StatusCode >= 300 { 10935 return out, metadata, awsRestxml_deserializeOpErrorPutPublicAccessBlock(response, &metadata) 10936 } 10937 output := &PutPublicAccessBlockOutput{} 10938 out.Result = output 10939 10940 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 10941 return out, metadata, &smithy.DeserializationError{ 10942 Err: fmt.Errorf("failed to discard response body, %w", err), 10943 } 10944 } 10945 10946 return out, metadata, err 10947} 10948 10949func awsRestxml_deserializeOpErrorPutPublicAccessBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10950 var errorBuffer bytes.Buffer 10951 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10952 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10953 } 10954 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10955 10956 errorCode := "UnknownError" 10957 errorMessage := errorCode 10958 10959 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 10960 UseStatusCode: true, StatusCode: response.StatusCode, 10961 }) 10962 if err != nil { 10963 return err 10964 } 10965 if hostID := errorComponents.HostID; len(hostID) != 0 { 10966 s3shared.SetHostIDMetadata(metadata, hostID) 10967 } 10968 if reqID := errorComponents.RequestID; len(reqID) != 0 { 10969 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 10970 } 10971 if len(errorComponents.Code) != 0 { 10972 errorCode = errorComponents.Code 10973 } 10974 if len(errorComponents.Message) != 0 { 10975 errorMessage = errorComponents.Message 10976 } 10977 errorBody.Seek(0, io.SeekStart) 10978 switch { 10979 default: 10980 genericError := &smithy.GenericAPIError{ 10981 Code: errorCode, 10982 Message: errorMessage, 10983 } 10984 return genericError 10985 10986 } 10987} 10988 10989type awsRestxml_deserializeOpRestoreObject struct { 10990} 10991 10992func (*awsRestxml_deserializeOpRestoreObject) ID() string { 10993 return "OperationDeserializer" 10994} 10995 10996func (m *awsRestxml_deserializeOpRestoreObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10997 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10998) { 10999 out, metadata, err = next.HandleDeserialize(ctx, in) 11000 if err != nil { 11001 return out, metadata, err 11002 } 11003 11004 response, ok := out.RawResponse.(*smithyhttp.Response) 11005 if !ok { 11006 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11007 } 11008 11009 if response.StatusCode < 200 || response.StatusCode >= 300 { 11010 return out, metadata, awsRestxml_deserializeOpErrorRestoreObject(response, &metadata) 11011 } 11012 output := &RestoreObjectOutput{} 11013 out.Result = output 11014 11015 err = awsRestxml_deserializeOpHttpBindingsRestoreObjectOutput(output, response) 11016 if err != nil { 11017 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 11018 } 11019 11020 return out, metadata, err 11021} 11022 11023func awsRestxml_deserializeOpErrorRestoreObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11024 var errorBuffer bytes.Buffer 11025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11027 } 11028 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11029 11030 errorCode := "UnknownError" 11031 errorMessage := errorCode 11032 11033 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11034 UseStatusCode: true, StatusCode: response.StatusCode, 11035 }) 11036 if err != nil { 11037 return err 11038 } 11039 if hostID := errorComponents.HostID; len(hostID) != 0 { 11040 s3shared.SetHostIDMetadata(metadata, hostID) 11041 } 11042 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11043 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11044 } 11045 if len(errorComponents.Code) != 0 { 11046 errorCode = errorComponents.Code 11047 } 11048 if len(errorComponents.Message) != 0 { 11049 errorMessage = errorComponents.Message 11050 } 11051 errorBody.Seek(0, io.SeekStart) 11052 switch { 11053 case strings.EqualFold("ObjectAlreadyInActiveTierError", errorCode): 11054 return awsRestxml_deserializeErrorObjectAlreadyInActiveTierError(response, errorBody) 11055 11056 default: 11057 genericError := &smithy.GenericAPIError{ 11058 Code: errorCode, 11059 Message: errorMessage, 11060 } 11061 return genericError 11062 11063 } 11064} 11065 11066func awsRestxml_deserializeOpHttpBindingsRestoreObjectOutput(v *RestoreObjectOutput, response *smithyhttp.Response) error { 11067 if v == nil { 11068 return fmt.Errorf("unsupported deserialization for nil %T", v) 11069 } 11070 11071 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 11072 headerValues[0] = strings.TrimSpace(headerValues[0]) 11073 v.RequestCharged = types.RequestCharged(headerValues[0]) 11074 } 11075 11076 if headerValues := response.Header.Values("x-amz-restore-output-path"); len(headerValues) != 0 { 11077 headerValues[0] = strings.TrimSpace(headerValues[0]) 11078 v.RestoreOutputPath = ptr.String(headerValues[0]) 11079 } 11080 11081 return nil 11082} 11083 11084type awsRestxml_deserializeOpUploadPart struct { 11085} 11086 11087func (*awsRestxml_deserializeOpUploadPart) ID() string { 11088 return "OperationDeserializer" 11089} 11090 11091func (m *awsRestxml_deserializeOpUploadPart) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11092 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11093) { 11094 out, metadata, err = next.HandleDeserialize(ctx, in) 11095 if err != nil { 11096 return out, metadata, err 11097 } 11098 11099 response, ok := out.RawResponse.(*smithyhttp.Response) 11100 if !ok { 11101 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11102 } 11103 11104 if response.StatusCode < 200 || response.StatusCode >= 300 { 11105 return out, metadata, awsRestxml_deserializeOpErrorUploadPart(response, &metadata) 11106 } 11107 output := &UploadPartOutput{} 11108 out.Result = output 11109 11110 err = awsRestxml_deserializeOpHttpBindingsUploadPartOutput(output, response) 11111 if err != nil { 11112 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 11113 } 11114 11115 return out, metadata, err 11116} 11117 11118func awsRestxml_deserializeOpErrorUploadPart(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11119 var errorBuffer bytes.Buffer 11120 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11121 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11122 } 11123 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11124 11125 errorCode := "UnknownError" 11126 errorMessage := errorCode 11127 11128 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11129 UseStatusCode: true, StatusCode: response.StatusCode, 11130 }) 11131 if err != nil { 11132 return err 11133 } 11134 if hostID := errorComponents.HostID; len(hostID) != 0 { 11135 s3shared.SetHostIDMetadata(metadata, hostID) 11136 } 11137 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11138 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11139 } 11140 if len(errorComponents.Code) != 0 { 11141 errorCode = errorComponents.Code 11142 } 11143 if len(errorComponents.Message) != 0 { 11144 errorMessage = errorComponents.Message 11145 } 11146 errorBody.Seek(0, io.SeekStart) 11147 switch { 11148 default: 11149 genericError := &smithy.GenericAPIError{ 11150 Code: errorCode, 11151 Message: errorMessage, 11152 } 11153 return genericError 11154 11155 } 11156} 11157 11158func awsRestxml_deserializeOpHttpBindingsUploadPartOutput(v *UploadPartOutput, response *smithyhttp.Response) error { 11159 if v == nil { 11160 return fmt.Errorf("unsupported deserialization for nil %T", v) 11161 } 11162 11163 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 11164 headerValues[0] = strings.TrimSpace(headerValues[0]) 11165 vv, err := strconv.ParseBool(headerValues[0]) 11166 if err != nil { 11167 return err 11168 } 11169 v.BucketKeyEnabled = vv 11170 } 11171 11172 if headerValues := response.Header.Values("ETag"); len(headerValues) != 0 { 11173 headerValues[0] = strings.TrimSpace(headerValues[0]) 11174 v.ETag = ptr.String(headerValues[0]) 11175 } 11176 11177 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 11178 headerValues[0] = strings.TrimSpace(headerValues[0]) 11179 v.RequestCharged = types.RequestCharged(headerValues[0]) 11180 } 11181 11182 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 11183 headerValues[0] = strings.TrimSpace(headerValues[0]) 11184 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 11185 } 11186 11187 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 11188 headerValues[0] = strings.TrimSpace(headerValues[0]) 11189 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 11190 } 11191 11192 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 11193 headerValues[0] = strings.TrimSpace(headerValues[0]) 11194 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 11195 } 11196 11197 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 11198 headerValues[0] = strings.TrimSpace(headerValues[0]) 11199 v.SSEKMSKeyId = ptr.String(headerValues[0]) 11200 } 11201 11202 return nil 11203} 11204 11205type awsRestxml_deserializeOpUploadPartCopy struct { 11206} 11207 11208func (*awsRestxml_deserializeOpUploadPartCopy) ID() string { 11209 return "OperationDeserializer" 11210} 11211 11212func (m *awsRestxml_deserializeOpUploadPartCopy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11213 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11214) { 11215 out, metadata, err = next.HandleDeserialize(ctx, in) 11216 if err != nil { 11217 return out, metadata, err 11218 } 11219 11220 response, ok := out.RawResponse.(*smithyhttp.Response) 11221 if !ok { 11222 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11223 } 11224 11225 if response.StatusCode < 200 || response.StatusCode >= 300 { 11226 return out, metadata, awsRestxml_deserializeOpErrorUploadPartCopy(response, &metadata) 11227 } 11228 output := &UploadPartCopyOutput{} 11229 out.Result = output 11230 11231 err = awsRestxml_deserializeOpHttpBindingsUploadPartCopyOutput(output, response) 11232 if err != nil { 11233 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 11234 } 11235 11236 var buff [1024]byte 11237 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11238 body := io.TeeReader(response.Body, ringBuffer) 11239 rootDecoder := xml.NewDecoder(body) 11240 t, err := smithyxml.FetchRootElement(rootDecoder) 11241 if err == io.EOF { 11242 return out, metadata, nil 11243 } 11244 if err != nil { 11245 var snapshot bytes.Buffer 11246 io.Copy(&snapshot, ringBuffer) 11247 return out, metadata, &smithy.DeserializationError{ 11248 Err: fmt.Errorf("failed to decode response body, %w", err), 11249 Snapshot: snapshot.Bytes(), 11250 } 11251 } 11252 11253 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11254 err = awsRestxml_deserializeDocumentCopyPartResult(&output.CopyPartResult, decoder) 11255 if err != nil { 11256 var snapshot bytes.Buffer 11257 io.Copy(&snapshot, ringBuffer) 11258 return out, metadata, &smithy.DeserializationError{ 11259 Err: fmt.Errorf("failed to decode response body, %w", err), 11260 Snapshot: snapshot.Bytes(), 11261 } 11262 } 11263 11264 return out, metadata, err 11265} 11266 11267func awsRestxml_deserializeOpErrorUploadPartCopy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11268 var errorBuffer bytes.Buffer 11269 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11270 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11271 } 11272 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11273 11274 errorCode := "UnknownError" 11275 errorMessage := errorCode 11276 11277 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11278 UseStatusCode: true, StatusCode: response.StatusCode, 11279 }) 11280 if err != nil { 11281 return err 11282 } 11283 if hostID := errorComponents.HostID; len(hostID) != 0 { 11284 s3shared.SetHostIDMetadata(metadata, hostID) 11285 } 11286 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11287 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11288 } 11289 if len(errorComponents.Code) != 0 { 11290 errorCode = errorComponents.Code 11291 } 11292 if len(errorComponents.Message) != 0 { 11293 errorMessage = errorComponents.Message 11294 } 11295 errorBody.Seek(0, io.SeekStart) 11296 switch { 11297 default: 11298 genericError := &smithy.GenericAPIError{ 11299 Code: errorCode, 11300 Message: errorMessage, 11301 } 11302 return genericError 11303 11304 } 11305} 11306 11307func awsRestxml_deserializeOpHttpBindingsUploadPartCopyOutput(v *UploadPartCopyOutput, response *smithyhttp.Response) error { 11308 if v == nil { 11309 return fmt.Errorf("unsupported deserialization for nil %T", v) 11310 } 11311 11312 if headerValues := response.Header.Values("x-amz-server-side-encryption-bucket-key-enabled"); len(headerValues) != 0 { 11313 headerValues[0] = strings.TrimSpace(headerValues[0]) 11314 vv, err := strconv.ParseBool(headerValues[0]) 11315 if err != nil { 11316 return err 11317 } 11318 v.BucketKeyEnabled = vv 11319 } 11320 11321 if headerValues := response.Header.Values("x-amz-copy-source-version-id"); len(headerValues) != 0 { 11322 headerValues[0] = strings.TrimSpace(headerValues[0]) 11323 v.CopySourceVersionId = ptr.String(headerValues[0]) 11324 } 11325 11326 if headerValues := response.Header.Values("x-amz-request-charged"); len(headerValues) != 0 { 11327 headerValues[0] = strings.TrimSpace(headerValues[0]) 11328 v.RequestCharged = types.RequestCharged(headerValues[0]) 11329 } 11330 11331 if headerValues := response.Header.Values("x-amz-server-side-encryption"); len(headerValues) != 0 { 11332 headerValues[0] = strings.TrimSpace(headerValues[0]) 11333 v.ServerSideEncryption = types.ServerSideEncryption(headerValues[0]) 11334 } 11335 11336 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-algorithm"); len(headerValues) != 0 { 11337 headerValues[0] = strings.TrimSpace(headerValues[0]) 11338 v.SSECustomerAlgorithm = ptr.String(headerValues[0]) 11339 } 11340 11341 if headerValues := response.Header.Values("x-amz-server-side-encryption-customer-key-MD5"); len(headerValues) != 0 { 11342 headerValues[0] = strings.TrimSpace(headerValues[0]) 11343 v.SSECustomerKeyMD5 = ptr.String(headerValues[0]) 11344 } 11345 11346 if headerValues := response.Header.Values("x-amz-server-side-encryption-aws-kms-key-id"); len(headerValues) != 0 { 11347 headerValues[0] = strings.TrimSpace(headerValues[0]) 11348 v.SSEKMSKeyId = ptr.String(headerValues[0]) 11349 } 11350 11351 return nil 11352} 11353func awsRestxml_deserializeOpDocumentUploadPartCopyOutput(v **UploadPartCopyOutput, decoder smithyxml.NodeDecoder) error { 11354 if v == nil { 11355 return fmt.Errorf("unexpected nil of type %T", v) 11356 } 11357 var sv *UploadPartCopyOutput 11358 if *v == nil { 11359 sv = &UploadPartCopyOutput{} 11360 } else { 11361 sv = *v 11362 } 11363 11364 for { 11365 t, done, err := decoder.Token() 11366 if err != nil { 11367 return err 11368 } 11369 if done { 11370 break 11371 } 11372 originalDecoder := decoder 11373 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11374 switch { 11375 case strings.EqualFold("CopyPartResult", t.Name.Local): 11376 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11377 if err := awsRestxml_deserializeDocumentCopyPartResult(&sv.CopyPartResult, nodeDecoder); err != nil { 11378 return err 11379 } 11380 11381 default: 11382 // Do nothing and ignore the unexpected tag element 11383 err = decoder.Decoder.Skip() 11384 if err != nil { 11385 return err 11386 } 11387 11388 } 11389 decoder = originalDecoder 11390 } 11391 *v = sv 11392 return nil 11393} 11394 11395type awsRestxml_deserializeOpWriteGetObjectResponse struct { 11396} 11397 11398func (*awsRestxml_deserializeOpWriteGetObjectResponse) ID() string { 11399 return "OperationDeserializer" 11400} 11401 11402func (m *awsRestxml_deserializeOpWriteGetObjectResponse) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 11403 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 11404) { 11405 out, metadata, err = next.HandleDeserialize(ctx, in) 11406 if err != nil { 11407 return out, metadata, err 11408 } 11409 11410 response, ok := out.RawResponse.(*smithyhttp.Response) 11411 if !ok { 11412 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 11413 } 11414 11415 if response.StatusCode < 200 || response.StatusCode >= 300 { 11416 return out, metadata, awsRestxml_deserializeOpErrorWriteGetObjectResponse(response, &metadata) 11417 } 11418 output := &WriteGetObjectResponseOutput{} 11419 out.Result = output 11420 11421 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 11422 return out, metadata, &smithy.DeserializationError{ 11423 Err: fmt.Errorf("failed to discard response body, %w", err), 11424 } 11425 } 11426 11427 return out, metadata, err 11428} 11429 11430func awsRestxml_deserializeOpErrorWriteGetObjectResponse(response *smithyhttp.Response, metadata *middleware.Metadata) error { 11431 var errorBuffer bytes.Buffer 11432 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 11433 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 11434 } 11435 errorBody := bytes.NewReader(errorBuffer.Bytes()) 11436 11437 errorCode := "UnknownError" 11438 errorMessage := errorCode 11439 11440 errorComponents, err := s3shared.GetErrorResponseComponents(errorBody, s3shared.ErrorResponseDeserializerOptions{ 11441 UseStatusCode: true, StatusCode: response.StatusCode, 11442 }) 11443 if err != nil { 11444 return err 11445 } 11446 if hostID := errorComponents.HostID; len(hostID) != 0 { 11447 s3shared.SetHostIDMetadata(metadata, hostID) 11448 } 11449 if reqID := errorComponents.RequestID; len(reqID) != 0 { 11450 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 11451 } 11452 if len(errorComponents.Code) != 0 { 11453 errorCode = errorComponents.Code 11454 } 11455 if len(errorComponents.Message) != 0 { 11456 errorMessage = errorComponents.Message 11457 } 11458 errorBody.Seek(0, io.SeekStart) 11459 switch { 11460 default: 11461 genericError := &smithy.GenericAPIError{ 11462 Code: errorCode, 11463 Message: errorMessage, 11464 } 11465 return genericError 11466 11467 } 11468} 11469 11470func awsRestxml_deserializeErrorBucketAlreadyExists(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11471 output := &types.BucketAlreadyExists{} 11472 return output 11473} 11474 11475func awsRestxml_deserializeErrorBucketAlreadyOwnedByYou(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11476 output := &types.BucketAlreadyOwnedByYou{} 11477 return output 11478} 11479 11480func awsRestxml_deserializeErrorInvalidObjectState(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11481 output := &types.InvalidObjectState{} 11482 var buff [1024]byte 11483 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11484 body := io.TeeReader(errorBody, ringBuffer) 11485 rootDecoder := xml.NewDecoder(body) 11486 t, err := smithyxml.FetchRootElement(rootDecoder) 11487 if err == io.EOF { 11488 return output 11489 } 11490 if err != nil { 11491 var snapshot bytes.Buffer 11492 io.Copy(&snapshot, ringBuffer) 11493 return &smithy.DeserializationError{ 11494 Err: fmt.Errorf("failed to decode response body, %w", err), 11495 Snapshot: snapshot.Bytes(), 11496 } 11497 } 11498 11499 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 11500 err = awsRestxml_deserializeDocumentInvalidObjectState(&output, decoder) 11501 if err != nil { 11502 var snapshot bytes.Buffer 11503 io.Copy(&snapshot, ringBuffer) 11504 return &smithy.DeserializationError{ 11505 Err: fmt.Errorf("failed to decode response body, %w", err), 11506 Snapshot: snapshot.Bytes(), 11507 } 11508 } 11509 11510 return output 11511} 11512 11513func awsRestxml_deserializeErrorNoSuchBucket(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11514 output := &types.NoSuchBucket{} 11515 return output 11516} 11517 11518func awsRestxml_deserializeErrorNoSuchKey(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11519 output := &types.NoSuchKey{} 11520 return output 11521} 11522 11523func awsRestxml_deserializeErrorNoSuchUpload(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11524 output := &types.NoSuchUpload{} 11525 return output 11526} 11527 11528func awsRestxml_deserializeErrorNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11529 output := &types.NotFound{} 11530 return output 11531} 11532 11533func awsRestxml_deserializeErrorObjectAlreadyInActiveTierError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11534 output := &types.ObjectAlreadyInActiveTierError{} 11535 return output 11536} 11537 11538func awsRestxml_deserializeErrorObjectNotInActiveTierError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11539 output := &types.ObjectNotInActiveTierError{} 11540 return output 11541} 11542 11543func awsRestxml_deserializeDocumentAbortIncompleteMultipartUpload(v **types.AbortIncompleteMultipartUpload, decoder smithyxml.NodeDecoder) error { 11544 if v == nil { 11545 return fmt.Errorf("unexpected nil of type %T", v) 11546 } 11547 var sv *types.AbortIncompleteMultipartUpload 11548 if *v == nil { 11549 sv = &types.AbortIncompleteMultipartUpload{} 11550 } else { 11551 sv = *v 11552 } 11553 11554 for { 11555 t, done, err := decoder.Token() 11556 if err != nil { 11557 return err 11558 } 11559 if done { 11560 break 11561 } 11562 originalDecoder := decoder 11563 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11564 switch { 11565 case strings.EqualFold("DaysAfterInitiation", t.Name.Local): 11566 val, err := decoder.Value() 11567 if err != nil { 11568 return err 11569 } 11570 if val == nil { 11571 break 11572 } 11573 { 11574 xtv := string(val) 11575 i64, err := strconv.ParseInt(xtv, 10, 64) 11576 if err != nil { 11577 return err 11578 } 11579 sv.DaysAfterInitiation = int32(i64) 11580 } 11581 11582 default: 11583 // Do nothing and ignore the unexpected tag element 11584 err = decoder.Decoder.Skip() 11585 if err != nil { 11586 return err 11587 } 11588 11589 } 11590 decoder = originalDecoder 11591 } 11592 *v = sv 11593 return nil 11594} 11595 11596func awsRestxml_deserializeDocumentAccessControlTranslation(v **types.AccessControlTranslation, decoder smithyxml.NodeDecoder) error { 11597 if v == nil { 11598 return fmt.Errorf("unexpected nil of type %T", v) 11599 } 11600 var sv *types.AccessControlTranslation 11601 if *v == nil { 11602 sv = &types.AccessControlTranslation{} 11603 } else { 11604 sv = *v 11605 } 11606 11607 for { 11608 t, done, err := decoder.Token() 11609 if err != nil { 11610 return err 11611 } 11612 if done { 11613 break 11614 } 11615 originalDecoder := decoder 11616 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11617 switch { 11618 case strings.EqualFold("Owner", t.Name.Local): 11619 val, err := decoder.Value() 11620 if err != nil { 11621 return err 11622 } 11623 if val == nil { 11624 break 11625 } 11626 { 11627 xtv := string(val) 11628 sv.Owner = types.OwnerOverride(xtv) 11629 } 11630 11631 default: 11632 // Do nothing and ignore the unexpected tag element 11633 err = decoder.Decoder.Skip() 11634 if err != nil { 11635 return err 11636 } 11637 11638 } 11639 decoder = originalDecoder 11640 } 11641 *v = sv 11642 return nil 11643} 11644 11645func awsRestxml_deserializeDocumentAllowedHeaders(v *[]string, decoder smithyxml.NodeDecoder) error { 11646 if v == nil { 11647 return fmt.Errorf("unexpected nil of type %T", v) 11648 } 11649 var sv []string 11650 if *v == nil { 11651 sv = make([]string, 0) 11652 } else { 11653 sv = *v 11654 } 11655 11656 originalDecoder := decoder 11657 for { 11658 t, done, err := decoder.Token() 11659 if err != nil { 11660 return err 11661 } 11662 if done { 11663 break 11664 } 11665 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11666 decoder = memberDecoder 11667 switch { 11668 case strings.EqualFold("member", t.Name.Local): 11669 var col string 11670 val, err := decoder.Value() 11671 if err != nil { 11672 return err 11673 } 11674 if val == nil { 11675 break 11676 } 11677 { 11678 xtv := string(val) 11679 col = xtv 11680 } 11681 sv = append(sv, col) 11682 11683 default: 11684 err = decoder.Decoder.Skip() 11685 if err != nil { 11686 return err 11687 } 11688 11689 } 11690 decoder = originalDecoder 11691 } 11692 *v = sv 11693 return nil 11694} 11695 11696func awsRestxml_deserializeDocumentAllowedHeadersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 11697 var sv []string 11698 if *v == nil { 11699 sv = make([]string, 0) 11700 } else { 11701 sv = *v 11702 } 11703 11704 switch { 11705 default: 11706 var mv string 11707 t := decoder.StartEl 11708 _ = t 11709 val, err := decoder.Value() 11710 if err != nil { 11711 return err 11712 } 11713 if val == nil { 11714 break 11715 } 11716 { 11717 xtv := string(val) 11718 mv = xtv 11719 } 11720 sv = append(sv, mv) 11721 } 11722 *v = sv 11723 return nil 11724} 11725func awsRestxml_deserializeDocumentAllowedMethods(v *[]string, decoder smithyxml.NodeDecoder) error { 11726 if v == nil { 11727 return fmt.Errorf("unexpected nil of type %T", v) 11728 } 11729 var sv []string 11730 if *v == nil { 11731 sv = make([]string, 0) 11732 } else { 11733 sv = *v 11734 } 11735 11736 originalDecoder := decoder 11737 for { 11738 t, done, err := decoder.Token() 11739 if err != nil { 11740 return err 11741 } 11742 if done { 11743 break 11744 } 11745 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11746 decoder = memberDecoder 11747 switch { 11748 case strings.EqualFold("member", t.Name.Local): 11749 var col string 11750 val, err := decoder.Value() 11751 if err != nil { 11752 return err 11753 } 11754 if val == nil { 11755 break 11756 } 11757 { 11758 xtv := string(val) 11759 col = xtv 11760 } 11761 sv = append(sv, col) 11762 11763 default: 11764 err = decoder.Decoder.Skip() 11765 if err != nil { 11766 return err 11767 } 11768 11769 } 11770 decoder = originalDecoder 11771 } 11772 *v = sv 11773 return nil 11774} 11775 11776func awsRestxml_deserializeDocumentAllowedMethodsUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 11777 var sv []string 11778 if *v == nil { 11779 sv = make([]string, 0) 11780 } else { 11781 sv = *v 11782 } 11783 11784 switch { 11785 default: 11786 var mv string 11787 t := decoder.StartEl 11788 _ = t 11789 val, err := decoder.Value() 11790 if err != nil { 11791 return err 11792 } 11793 if val == nil { 11794 break 11795 } 11796 { 11797 xtv := string(val) 11798 mv = xtv 11799 } 11800 sv = append(sv, mv) 11801 } 11802 *v = sv 11803 return nil 11804} 11805func awsRestxml_deserializeDocumentAllowedOrigins(v *[]string, decoder smithyxml.NodeDecoder) error { 11806 if v == nil { 11807 return fmt.Errorf("unexpected nil of type %T", v) 11808 } 11809 var sv []string 11810 if *v == nil { 11811 sv = make([]string, 0) 11812 } else { 11813 sv = *v 11814 } 11815 11816 originalDecoder := decoder 11817 for { 11818 t, done, err := decoder.Token() 11819 if err != nil { 11820 return err 11821 } 11822 if done { 11823 break 11824 } 11825 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11826 decoder = memberDecoder 11827 switch { 11828 case strings.EqualFold("member", t.Name.Local): 11829 var col string 11830 val, err := decoder.Value() 11831 if err != nil { 11832 return err 11833 } 11834 if val == nil { 11835 break 11836 } 11837 { 11838 xtv := string(val) 11839 col = xtv 11840 } 11841 sv = append(sv, col) 11842 11843 default: 11844 err = decoder.Decoder.Skip() 11845 if err != nil { 11846 return err 11847 } 11848 11849 } 11850 decoder = originalDecoder 11851 } 11852 *v = sv 11853 return nil 11854} 11855 11856func awsRestxml_deserializeDocumentAllowedOriginsUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 11857 var sv []string 11858 if *v == nil { 11859 sv = make([]string, 0) 11860 } else { 11861 sv = *v 11862 } 11863 11864 switch { 11865 default: 11866 var mv string 11867 t := decoder.StartEl 11868 _ = t 11869 val, err := decoder.Value() 11870 if err != nil { 11871 return err 11872 } 11873 if val == nil { 11874 break 11875 } 11876 { 11877 xtv := string(val) 11878 mv = xtv 11879 } 11880 sv = append(sv, mv) 11881 } 11882 *v = sv 11883 return nil 11884} 11885func awsRestxml_deserializeDocumentAnalyticsAndOperator(v **types.AnalyticsAndOperator, decoder smithyxml.NodeDecoder) error { 11886 if v == nil { 11887 return fmt.Errorf("unexpected nil of type %T", v) 11888 } 11889 var sv *types.AnalyticsAndOperator 11890 if *v == nil { 11891 sv = &types.AnalyticsAndOperator{} 11892 } else { 11893 sv = *v 11894 } 11895 11896 for { 11897 t, done, err := decoder.Token() 11898 if err != nil { 11899 return err 11900 } 11901 if done { 11902 break 11903 } 11904 originalDecoder := decoder 11905 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11906 switch { 11907 case strings.EqualFold("Prefix", t.Name.Local): 11908 val, err := decoder.Value() 11909 if err != nil { 11910 return err 11911 } 11912 if val == nil { 11913 break 11914 } 11915 { 11916 xtv := string(val) 11917 sv.Prefix = ptr.String(xtv) 11918 } 11919 11920 case strings.EqualFold("Tag", t.Name.Local): 11921 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11922 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 11923 return err 11924 } 11925 11926 default: 11927 // Do nothing and ignore the unexpected tag element 11928 err = decoder.Decoder.Skip() 11929 if err != nil { 11930 return err 11931 } 11932 11933 } 11934 decoder = originalDecoder 11935 } 11936 *v = sv 11937 return nil 11938} 11939 11940func awsRestxml_deserializeDocumentAnalyticsConfiguration(v **types.AnalyticsConfiguration, decoder smithyxml.NodeDecoder) error { 11941 if v == nil { 11942 return fmt.Errorf("unexpected nil of type %T", v) 11943 } 11944 var sv *types.AnalyticsConfiguration 11945 if *v == nil { 11946 sv = &types.AnalyticsConfiguration{} 11947 } else { 11948 sv = *v 11949 } 11950 11951 for { 11952 t, done, err := decoder.Token() 11953 if err != nil { 11954 return err 11955 } 11956 if done { 11957 break 11958 } 11959 originalDecoder := decoder 11960 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 11961 switch { 11962 case strings.EqualFold("Filter", t.Name.Local): 11963 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11964 if err := awsRestxml_deserializeDocumentAnalyticsFilter(&sv.Filter, nodeDecoder); err != nil { 11965 return err 11966 } 11967 11968 case strings.EqualFold("Id", t.Name.Local): 11969 val, err := decoder.Value() 11970 if err != nil { 11971 return err 11972 } 11973 if val == nil { 11974 break 11975 } 11976 { 11977 xtv := string(val) 11978 sv.Id = ptr.String(xtv) 11979 } 11980 11981 case strings.EqualFold("StorageClassAnalysis", t.Name.Local): 11982 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 11983 if err := awsRestxml_deserializeDocumentStorageClassAnalysis(&sv.StorageClassAnalysis, nodeDecoder); err != nil { 11984 return err 11985 } 11986 11987 default: 11988 // Do nothing and ignore the unexpected tag element 11989 err = decoder.Decoder.Skip() 11990 if err != nil { 11991 return err 11992 } 11993 11994 } 11995 decoder = originalDecoder 11996 } 11997 *v = sv 11998 return nil 11999} 12000 12001func awsRestxml_deserializeDocumentAnalyticsConfigurationList(v *[]types.AnalyticsConfiguration, decoder smithyxml.NodeDecoder) error { 12002 if v == nil { 12003 return fmt.Errorf("unexpected nil of type %T", v) 12004 } 12005 var sv []types.AnalyticsConfiguration 12006 if *v == nil { 12007 sv = make([]types.AnalyticsConfiguration, 0) 12008 } else { 12009 sv = *v 12010 } 12011 12012 originalDecoder := decoder 12013 for { 12014 t, done, err := decoder.Token() 12015 if err != nil { 12016 return err 12017 } 12018 if done { 12019 break 12020 } 12021 switch { 12022 case strings.EqualFold("member", t.Name.Local): 12023 var col types.AnalyticsConfiguration 12024 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12025 destAddr := &col 12026 if err := awsRestxml_deserializeDocumentAnalyticsConfiguration(&destAddr, nodeDecoder); err != nil { 12027 return err 12028 } 12029 col = *destAddr 12030 sv = append(sv, col) 12031 12032 default: 12033 err = decoder.Decoder.Skip() 12034 if err != nil { 12035 return err 12036 } 12037 12038 } 12039 decoder = originalDecoder 12040 } 12041 *v = sv 12042 return nil 12043} 12044 12045func awsRestxml_deserializeDocumentAnalyticsConfigurationListUnwrapped(v *[]types.AnalyticsConfiguration, decoder smithyxml.NodeDecoder) error { 12046 var sv []types.AnalyticsConfiguration 12047 if *v == nil { 12048 sv = make([]types.AnalyticsConfiguration, 0) 12049 } else { 12050 sv = *v 12051 } 12052 12053 switch { 12054 default: 12055 var mv types.AnalyticsConfiguration 12056 t := decoder.StartEl 12057 _ = t 12058 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12059 destAddr := &mv 12060 if err := awsRestxml_deserializeDocumentAnalyticsConfiguration(&destAddr, nodeDecoder); err != nil { 12061 return err 12062 } 12063 mv = *destAddr 12064 sv = append(sv, mv) 12065 } 12066 *v = sv 12067 return nil 12068} 12069func awsRestxml_deserializeDocumentAnalyticsExportDestination(v **types.AnalyticsExportDestination, decoder smithyxml.NodeDecoder) error { 12070 if v == nil { 12071 return fmt.Errorf("unexpected nil of type %T", v) 12072 } 12073 var sv *types.AnalyticsExportDestination 12074 if *v == nil { 12075 sv = &types.AnalyticsExportDestination{} 12076 } else { 12077 sv = *v 12078 } 12079 12080 for { 12081 t, done, err := decoder.Token() 12082 if err != nil { 12083 return err 12084 } 12085 if done { 12086 break 12087 } 12088 originalDecoder := decoder 12089 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12090 switch { 12091 case strings.EqualFold("S3BucketDestination", t.Name.Local): 12092 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12093 if err := awsRestxml_deserializeDocumentAnalyticsS3BucketDestination(&sv.S3BucketDestination, nodeDecoder); err != nil { 12094 return err 12095 } 12096 12097 default: 12098 // Do nothing and ignore the unexpected tag element 12099 err = decoder.Decoder.Skip() 12100 if err != nil { 12101 return err 12102 } 12103 12104 } 12105 decoder = originalDecoder 12106 } 12107 *v = sv 12108 return nil 12109} 12110 12111func awsRestxml_deserializeDocumentAnalyticsFilter(v *types.AnalyticsFilter, decoder smithyxml.NodeDecoder) error { 12112 if v == nil { 12113 return fmt.Errorf("unexpected nil of type %T", v) 12114 } 12115 var uv types.AnalyticsFilter 12116 var memberFound bool 12117 for { 12118 t, done, err := decoder.Token() 12119 if err != nil { 12120 return err 12121 } 12122 if done { 12123 break 12124 } 12125 if memberFound { 12126 if err = decoder.Decoder.Skip(); err != nil { 12127 return err 12128 } 12129 } 12130 originalDecoder := decoder 12131 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12132 switch { 12133 case strings.EqualFold("And", t.Name.Local): 12134 var mv types.AnalyticsAndOperator 12135 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12136 destAddr := &mv 12137 if err := awsRestxml_deserializeDocumentAnalyticsAndOperator(&destAddr, nodeDecoder); err != nil { 12138 return err 12139 } 12140 mv = *destAddr 12141 uv = &types.AnalyticsFilterMemberAnd{Value: mv} 12142 memberFound = true 12143 12144 case strings.EqualFold("Prefix", t.Name.Local): 12145 var mv string 12146 val, err := decoder.Value() 12147 if err != nil { 12148 return err 12149 } 12150 if val == nil { 12151 break 12152 } 12153 { 12154 xtv := string(val) 12155 mv = xtv 12156 } 12157 uv = &types.AnalyticsFilterMemberPrefix{Value: mv} 12158 memberFound = true 12159 12160 case strings.EqualFold("Tag", t.Name.Local): 12161 var mv types.Tag 12162 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12163 destAddr := &mv 12164 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 12165 return err 12166 } 12167 mv = *destAddr 12168 uv = &types.AnalyticsFilterMemberTag{Value: mv} 12169 memberFound = true 12170 12171 default: 12172 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 12173 memberFound = true 12174 12175 } 12176 decoder = originalDecoder 12177 } 12178 *v = uv 12179 return nil 12180} 12181 12182func awsRestxml_deserializeDocumentAnalyticsS3BucketDestination(v **types.AnalyticsS3BucketDestination, decoder smithyxml.NodeDecoder) error { 12183 if v == nil { 12184 return fmt.Errorf("unexpected nil of type %T", v) 12185 } 12186 var sv *types.AnalyticsS3BucketDestination 12187 if *v == nil { 12188 sv = &types.AnalyticsS3BucketDestination{} 12189 } else { 12190 sv = *v 12191 } 12192 12193 for { 12194 t, done, err := decoder.Token() 12195 if err != nil { 12196 return err 12197 } 12198 if done { 12199 break 12200 } 12201 originalDecoder := decoder 12202 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12203 switch { 12204 case strings.EqualFold("Bucket", t.Name.Local): 12205 val, err := decoder.Value() 12206 if err != nil { 12207 return err 12208 } 12209 if val == nil { 12210 break 12211 } 12212 { 12213 xtv := string(val) 12214 sv.Bucket = ptr.String(xtv) 12215 } 12216 12217 case strings.EqualFold("BucketAccountId", t.Name.Local): 12218 val, err := decoder.Value() 12219 if err != nil { 12220 return err 12221 } 12222 if val == nil { 12223 break 12224 } 12225 { 12226 xtv := string(val) 12227 sv.BucketAccountId = ptr.String(xtv) 12228 } 12229 12230 case strings.EqualFold("Format", t.Name.Local): 12231 val, err := decoder.Value() 12232 if err != nil { 12233 return err 12234 } 12235 if val == nil { 12236 break 12237 } 12238 { 12239 xtv := string(val) 12240 sv.Format = types.AnalyticsS3ExportFileFormat(xtv) 12241 } 12242 12243 case strings.EqualFold("Prefix", t.Name.Local): 12244 val, err := decoder.Value() 12245 if err != nil { 12246 return err 12247 } 12248 if val == nil { 12249 break 12250 } 12251 { 12252 xtv := string(val) 12253 sv.Prefix = ptr.String(xtv) 12254 } 12255 12256 default: 12257 // Do nothing and ignore the unexpected tag element 12258 err = decoder.Decoder.Skip() 12259 if err != nil { 12260 return err 12261 } 12262 12263 } 12264 decoder = originalDecoder 12265 } 12266 *v = sv 12267 return nil 12268} 12269 12270func awsRestxml_deserializeDocumentBucket(v **types.Bucket, decoder smithyxml.NodeDecoder) error { 12271 if v == nil { 12272 return fmt.Errorf("unexpected nil of type %T", v) 12273 } 12274 var sv *types.Bucket 12275 if *v == nil { 12276 sv = &types.Bucket{} 12277 } else { 12278 sv = *v 12279 } 12280 12281 for { 12282 t, done, err := decoder.Token() 12283 if err != nil { 12284 return err 12285 } 12286 if done { 12287 break 12288 } 12289 originalDecoder := decoder 12290 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12291 switch { 12292 case strings.EqualFold("CreationDate", 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 t, err := smithytime.ParseDateTime(xtv) 12303 if err != nil { 12304 return err 12305 } 12306 sv.CreationDate = ptr.Time(t) 12307 } 12308 12309 case strings.EqualFold("Name", t.Name.Local): 12310 val, err := decoder.Value() 12311 if err != nil { 12312 return err 12313 } 12314 if val == nil { 12315 break 12316 } 12317 { 12318 xtv := string(val) 12319 sv.Name = ptr.String(xtv) 12320 } 12321 12322 default: 12323 // Do nothing and ignore the unexpected tag element 12324 err = decoder.Decoder.Skip() 12325 if err != nil { 12326 return err 12327 } 12328 12329 } 12330 decoder = originalDecoder 12331 } 12332 *v = sv 12333 return nil 12334} 12335 12336func awsRestxml_deserializeDocumentBucketAlreadyExists(v **types.BucketAlreadyExists, decoder smithyxml.NodeDecoder) error { 12337 if v == nil { 12338 return fmt.Errorf("unexpected nil of type %T", v) 12339 } 12340 var sv *types.BucketAlreadyExists 12341 if *v == nil { 12342 sv = &types.BucketAlreadyExists{} 12343 } else { 12344 sv = *v 12345 } 12346 12347 for { 12348 t, done, err := decoder.Token() 12349 if err != nil { 12350 return err 12351 } 12352 if done { 12353 break 12354 } 12355 originalDecoder := decoder 12356 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12357 switch { 12358 default: 12359 // Do nothing and ignore the unexpected tag element 12360 err = decoder.Decoder.Skip() 12361 if err != nil { 12362 return err 12363 } 12364 12365 } 12366 decoder = originalDecoder 12367 } 12368 *v = sv 12369 return nil 12370} 12371 12372func awsRestxml_deserializeDocumentBucketAlreadyOwnedByYou(v **types.BucketAlreadyOwnedByYou, decoder smithyxml.NodeDecoder) error { 12373 if v == nil { 12374 return fmt.Errorf("unexpected nil of type %T", v) 12375 } 12376 var sv *types.BucketAlreadyOwnedByYou 12377 if *v == nil { 12378 sv = &types.BucketAlreadyOwnedByYou{} 12379 } else { 12380 sv = *v 12381 } 12382 12383 for { 12384 t, done, err := decoder.Token() 12385 if err != nil { 12386 return err 12387 } 12388 if done { 12389 break 12390 } 12391 originalDecoder := decoder 12392 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12393 switch { 12394 default: 12395 // Do nothing and ignore the unexpected tag element 12396 err = decoder.Decoder.Skip() 12397 if err != nil { 12398 return err 12399 } 12400 12401 } 12402 decoder = originalDecoder 12403 } 12404 *v = sv 12405 return nil 12406} 12407 12408func awsRestxml_deserializeDocumentBuckets(v *[]types.Bucket, decoder smithyxml.NodeDecoder) error { 12409 if v == nil { 12410 return fmt.Errorf("unexpected nil of type %T", v) 12411 } 12412 var sv []types.Bucket 12413 if *v == nil { 12414 sv = make([]types.Bucket, 0) 12415 } else { 12416 sv = *v 12417 } 12418 12419 originalDecoder := decoder 12420 for { 12421 t, done, err := decoder.Token() 12422 if err != nil { 12423 return err 12424 } 12425 if done { 12426 break 12427 } 12428 switch { 12429 case strings.EqualFold("Bucket", t.Name.Local): 12430 var col types.Bucket 12431 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12432 destAddr := &col 12433 if err := awsRestxml_deserializeDocumentBucket(&destAddr, nodeDecoder); err != nil { 12434 return err 12435 } 12436 col = *destAddr 12437 sv = append(sv, col) 12438 12439 default: 12440 err = decoder.Decoder.Skip() 12441 if err != nil { 12442 return err 12443 } 12444 12445 } 12446 decoder = originalDecoder 12447 } 12448 *v = sv 12449 return nil 12450} 12451 12452func awsRestxml_deserializeDocumentBucketsUnwrapped(v *[]types.Bucket, decoder smithyxml.NodeDecoder) error { 12453 var sv []types.Bucket 12454 if *v == nil { 12455 sv = make([]types.Bucket, 0) 12456 } else { 12457 sv = *v 12458 } 12459 12460 switch { 12461 default: 12462 var mv types.Bucket 12463 t := decoder.StartEl 12464 _ = t 12465 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12466 destAddr := &mv 12467 if err := awsRestxml_deserializeDocumentBucket(&destAddr, nodeDecoder); err != nil { 12468 return err 12469 } 12470 mv = *destAddr 12471 sv = append(sv, mv) 12472 } 12473 *v = sv 12474 return nil 12475} 12476func awsRestxml_deserializeDocumentCommonPrefix(v **types.CommonPrefix, decoder smithyxml.NodeDecoder) error { 12477 if v == nil { 12478 return fmt.Errorf("unexpected nil of type %T", v) 12479 } 12480 var sv *types.CommonPrefix 12481 if *v == nil { 12482 sv = &types.CommonPrefix{} 12483 } else { 12484 sv = *v 12485 } 12486 12487 for { 12488 t, done, err := decoder.Token() 12489 if err != nil { 12490 return err 12491 } 12492 if done { 12493 break 12494 } 12495 originalDecoder := decoder 12496 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12497 switch { 12498 case strings.EqualFold("Prefix", t.Name.Local): 12499 val, err := decoder.Value() 12500 if err != nil { 12501 return err 12502 } 12503 if val == nil { 12504 break 12505 } 12506 { 12507 xtv := string(val) 12508 sv.Prefix = ptr.String(xtv) 12509 } 12510 12511 default: 12512 // Do nothing and ignore the unexpected tag element 12513 err = decoder.Decoder.Skip() 12514 if err != nil { 12515 return err 12516 } 12517 12518 } 12519 decoder = originalDecoder 12520 } 12521 *v = sv 12522 return nil 12523} 12524 12525func awsRestxml_deserializeDocumentCommonPrefixList(v *[]types.CommonPrefix, decoder smithyxml.NodeDecoder) error { 12526 if v == nil { 12527 return fmt.Errorf("unexpected nil of type %T", v) 12528 } 12529 var sv []types.CommonPrefix 12530 if *v == nil { 12531 sv = make([]types.CommonPrefix, 0) 12532 } else { 12533 sv = *v 12534 } 12535 12536 originalDecoder := decoder 12537 for { 12538 t, done, err := decoder.Token() 12539 if err != nil { 12540 return err 12541 } 12542 if done { 12543 break 12544 } 12545 switch { 12546 case strings.EqualFold("member", t.Name.Local): 12547 var col types.CommonPrefix 12548 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12549 destAddr := &col 12550 if err := awsRestxml_deserializeDocumentCommonPrefix(&destAddr, nodeDecoder); err != nil { 12551 return err 12552 } 12553 col = *destAddr 12554 sv = append(sv, col) 12555 12556 default: 12557 err = decoder.Decoder.Skip() 12558 if err != nil { 12559 return err 12560 } 12561 12562 } 12563 decoder = originalDecoder 12564 } 12565 *v = sv 12566 return nil 12567} 12568 12569func awsRestxml_deserializeDocumentCommonPrefixListUnwrapped(v *[]types.CommonPrefix, decoder smithyxml.NodeDecoder) error { 12570 var sv []types.CommonPrefix 12571 if *v == nil { 12572 sv = make([]types.CommonPrefix, 0) 12573 } else { 12574 sv = *v 12575 } 12576 12577 switch { 12578 default: 12579 var mv types.CommonPrefix 12580 t := decoder.StartEl 12581 _ = t 12582 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12583 destAddr := &mv 12584 if err := awsRestxml_deserializeDocumentCommonPrefix(&destAddr, nodeDecoder); err != nil { 12585 return err 12586 } 12587 mv = *destAddr 12588 sv = append(sv, mv) 12589 } 12590 *v = sv 12591 return nil 12592} 12593func awsRestxml_deserializeDocumentCondition(v **types.Condition, decoder smithyxml.NodeDecoder) error { 12594 if v == nil { 12595 return fmt.Errorf("unexpected nil of type %T", v) 12596 } 12597 var sv *types.Condition 12598 if *v == nil { 12599 sv = &types.Condition{} 12600 } else { 12601 sv = *v 12602 } 12603 12604 for { 12605 t, done, err := decoder.Token() 12606 if err != nil { 12607 return err 12608 } 12609 if done { 12610 break 12611 } 12612 originalDecoder := decoder 12613 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12614 switch { 12615 case strings.EqualFold("HttpErrorCodeReturnedEquals", t.Name.Local): 12616 val, err := decoder.Value() 12617 if err != nil { 12618 return err 12619 } 12620 if val == nil { 12621 break 12622 } 12623 { 12624 xtv := string(val) 12625 sv.HttpErrorCodeReturnedEquals = ptr.String(xtv) 12626 } 12627 12628 case strings.EqualFold("KeyPrefixEquals", t.Name.Local): 12629 val, err := decoder.Value() 12630 if err != nil { 12631 return err 12632 } 12633 if val == nil { 12634 break 12635 } 12636 { 12637 xtv := string(val) 12638 sv.KeyPrefixEquals = ptr.String(xtv) 12639 } 12640 12641 default: 12642 // Do nothing and ignore the unexpected tag element 12643 err = decoder.Decoder.Skip() 12644 if err != nil { 12645 return err 12646 } 12647 12648 } 12649 decoder = originalDecoder 12650 } 12651 *v = sv 12652 return nil 12653} 12654 12655func awsRestxml_deserializeDocumentCopyObjectResult(v **types.CopyObjectResult, decoder smithyxml.NodeDecoder) error { 12656 if v == nil { 12657 return fmt.Errorf("unexpected nil of type %T", v) 12658 } 12659 var sv *types.CopyObjectResult 12660 if *v == nil { 12661 sv = &types.CopyObjectResult{} 12662 } else { 12663 sv = *v 12664 } 12665 12666 for { 12667 t, done, err := decoder.Token() 12668 if err != nil { 12669 return err 12670 } 12671 if done { 12672 break 12673 } 12674 originalDecoder := decoder 12675 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12676 switch { 12677 case strings.EqualFold("ETag", t.Name.Local): 12678 val, err := decoder.Value() 12679 if err != nil { 12680 return err 12681 } 12682 if val == nil { 12683 break 12684 } 12685 { 12686 xtv := string(val) 12687 sv.ETag = ptr.String(xtv) 12688 } 12689 12690 case strings.EqualFold("LastModified", t.Name.Local): 12691 val, err := decoder.Value() 12692 if err != nil { 12693 return err 12694 } 12695 if val == nil { 12696 break 12697 } 12698 { 12699 xtv := string(val) 12700 t, err := smithytime.ParseDateTime(xtv) 12701 if err != nil { 12702 return err 12703 } 12704 sv.LastModified = ptr.Time(t) 12705 } 12706 12707 default: 12708 // Do nothing and ignore the unexpected tag element 12709 err = decoder.Decoder.Skip() 12710 if err != nil { 12711 return err 12712 } 12713 12714 } 12715 decoder = originalDecoder 12716 } 12717 *v = sv 12718 return nil 12719} 12720 12721func awsRestxml_deserializeDocumentCopyPartResult(v **types.CopyPartResult, decoder smithyxml.NodeDecoder) error { 12722 if v == nil { 12723 return fmt.Errorf("unexpected nil of type %T", v) 12724 } 12725 var sv *types.CopyPartResult 12726 if *v == nil { 12727 sv = &types.CopyPartResult{} 12728 } else { 12729 sv = *v 12730 } 12731 12732 for { 12733 t, done, err := decoder.Token() 12734 if err != nil { 12735 return err 12736 } 12737 if done { 12738 break 12739 } 12740 originalDecoder := decoder 12741 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12742 switch { 12743 case strings.EqualFold("ETag", t.Name.Local): 12744 val, err := decoder.Value() 12745 if err != nil { 12746 return err 12747 } 12748 if val == nil { 12749 break 12750 } 12751 { 12752 xtv := string(val) 12753 sv.ETag = ptr.String(xtv) 12754 } 12755 12756 case strings.EqualFold("LastModified", t.Name.Local): 12757 val, err := decoder.Value() 12758 if err != nil { 12759 return err 12760 } 12761 if val == nil { 12762 break 12763 } 12764 { 12765 xtv := string(val) 12766 t, err := smithytime.ParseDateTime(xtv) 12767 if err != nil { 12768 return err 12769 } 12770 sv.LastModified = ptr.Time(t) 12771 } 12772 12773 default: 12774 // Do nothing and ignore the unexpected tag element 12775 err = decoder.Decoder.Skip() 12776 if err != nil { 12777 return err 12778 } 12779 12780 } 12781 decoder = originalDecoder 12782 } 12783 *v = sv 12784 return nil 12785} 12786 12787func awsRestxml_deserializeDocumentCORSRule(v **types.CORSRule, decoder smithyxml.NodeDecoder) error { 12788 if v == nil { 12789 return fmt.Errorf("unexpected nil of type %T", v) 12790 } 12791 var sv *types.CORSRule 12792 if *v == nil { 12793 sv = &types.CORSRule{} 12794 } else { 12795 sv = *v 12796 } 12797 12798 for { 12799 t, done, err := decoder.Token() 12800 if err != nil { 12801 return err 12802 } 12803 if done { 12804 break 12805 } 12806 originalDecoder := decoder 12807 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12808 switch { 12809 case strings.EqualFold("AllowedHeader", t.Name.Local): 12810 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12811 if err := awsRestxml_deserializeDocumentAllowedHeadersUnwrapped(&sv.AllowedHeaders, nodeDecoder); err != nil { 12812 return err 12813 } 12814 12815 case strings.EqualFold("AllowedMethod", t.Name.Local): 12816 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12817 if err := awsRestxml_deserializeDocumentAllowedMethodsUnwrapped(&sv.AllowedMethods, nodeDecoder); err != nil { 12818 return err 12819 } 12820 12821 case strings.EqualFold("AllowedOrigin", t.Name.Local): 12822 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12823 if err := awsRestxml_deserializeDocumentAllowedOriginsUnwrapped(&sv.AllowedOrigins, nodeDecoder); err != nil { 12824 return err 12825 } 12826 12827 case strings.EqualFold("ExposeHeader", t.Name.Local): 12828 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12829 if err := awsRestxml_deserializeDocumentExposeHeadersUnwrapped(&sv.ExposeHeaders, nodeDecoder); err != nil { 12830 return err 12831 } 12832 12833 case strings.EqualFold("ID", t.Name.Local): 12834 val, err := decoder.Value() 12835 if err != nil { 12836 return err 12837 } 12838 if val == nil { 12839 break 12840 } 12841 { 12842 xtv := string(val) 12843 sv.ID = ptr.String(xtv) 12844 } 12845 12846 case strings.EqualFold("MaxAgeSeconds", t.Name.Local): 12847 val, err := decoder.Value() 12848 if err != nil { 12849 return err 12850 } 12851 if val == nil { 12852 break 12853 } 12854 { 12855 xtv := string(val) 12856 i64, err := strconv.ParseInt(xtv, 10, 64) 12857 if err != nil { 12858 return err 12859 } 12860 sv.MaxAgeSeconds = int32(i64) 12861 } 12862 12863 default: 12864 // Do nothing and ignore the unexpected tag element 12865 err = decoder.Decoder.Skip() 12866 if err != nil { 12867 return err 12868 } 12869 12870 } 12871 decoder = originalDecoder 12872 } 12873 *v = sv 12874 return nil 12875} 12876 12877func awsRestxml_deserializeDocumentCORSRules(v *[]types.CORSRule, decoder smithyxml.NodeDecoder) error { 12878 if v == nil { 12879 return fmt.Errorf("unexpected nil of type %T", v) 12880 } 12881 var sv []types.CORSRule 12882 if *v == nil { 12883 sv = make([]types.CORSRule, 0) 12884 } else { 12885 sv = *v 12886 } 12887 12888 originalDecoder := decoder 12889 for { 12890 t, done, err := decoder.Token() 12891 if err != nil { 12892 return err 12893 } 12894 if done { 12895 break 12896 } 12897 switch { 12898 case strings.EqualFold("member", t.Name.Local): 12899 var col types.CORSRule 12900 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12901 destAddr := &col 12902 if err := awsRestxml_deserializeDocumentCORSRule(&destAddr, nodeDecoder); err != nil { 12903 return err 12904 } 12905 col = *destAddr 12906 sv = append(sv, col) 12907 12908 default: 12909 err = decoder.Decoder.Skip() 12910 if err != nil { 12911 return err 12912 } 12913 12914 } 12915 decoder = originalDecoder 12916 } 12917 *v = sv 12918 return nil 12919} 12920 12921func awsRestxml_deserializeDocumentCORSRulesUnwrapped(v *[]types.CORSRule, decoder smithyxml.NodeDecoder) error { 12922 var sv []types.CORSRule 12923 if *v == nil { 12924 sv = make([]types.CORSRule, 0) 12925 } else { 12926 sv = *v 12927 } 12928 12929 switch { 12930 default: 12931 var mv types.CORSRule 12932 t := decoder.StartEl 12933 _ = t 12934 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 12935 destAddr := &mv 12936 if err := awsRestxml_deserializeDocumentCORSRule(&destAddr, nodeDecoder); err != nil { 12937 return err 12938 } 12939 mv = *destAddr 12940 sv = append(sv, mv) 12941 } 12942 *v = sv 12943 return nil 12944} 12945func awsRestxml_deserializeDocumentDefaultRetention(v **types.DefaultRetention, decoder smithyxml.NodeDecoder) error { 12946 if v == nil { 12947 return fmt.Errorf("unexpected nil of type %T", v) 12948 } 12949 var sv *types.DefaultRetention 12950 if *v == nil { 12951 sv = &types.DefaultRetention{} 12952 } else { 12953 sv = *v 12954 } 12955 12956 for { 12957 t, done, err := decoder.Token() 12958 if err != nil { 12959 return err 12960 } 12961 if done { 12962 break 12963 } 12964 originalDecoder := decoder 12965 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 12966 switch { 12967 case strings.EqualFold("Days", 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.Days = int32(i64) 12982 } 12983 12984 case strings.EqualFold("Mode", t.Name.Local): 12985 val, err := decoder.Value() 12986 if err != nil { 12987 return err 12988 } 12989 if val == nil { 12990 break 12991 } 12992 { 12993 xtv := string(val) 12994 sv.Mode = types.ObjectLockRetentionMode(xtv) 12995 } 12996 12997 case strings.EqualFold("Years", t.Name.Local): 12998 val, err := decoder.Value() 12999 if err != nil { 13000 return err 13001 } 13002 if val == nil { 13003 break 13004 } 13005 { 13006 xtv := string(val) 13007 i64, err := strconv.ParseInt(xtv, 10, 64) 13008 if err != nil { 13009 return err 13010 } 13011 sv.Years = int32(i64) 13012 } 13013 13014 default: 13015 // Do nothing and ignore the unexpected tag element 13016 err = decoder.Decoder.Skip() 13017 if err != nil { 13018 return err 13019 } 13020 13021 } 13022 decoder = originalDecoder 13023 } 13024 *v = sv 13025 return nil 13026} 13027 13028func awsRestxml_deserializeDocumentDeletedObject(v **types.DeletedObject, decoder smithyxml.NodeDecoder) error { 13029 if v == nil { 13030 return fmt.Errorf("unexpected nil of type %T", v) 13031 } 13032 var sv *types.DeletedObject 13033 if *v == nil { 13034 sv = &types.DeletedObject{} 13035 } else { 13036 sv = *v 13037 } 13038 13039 for { 13040 t, done, err := decoder.Token() 13041 if err != nil { 13042 return err 13043 } 13044 if done { 13045 break 13046 } 13047 originalDecoder := decoder 13048 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13049 switch { 13050 case strings.EqualFold("DeleteMarker", t.Name.Local): 13051 val, err := decoder.Value() 13052 if err != nil { 13053 return err 13054 } 13055 if val == nil { 13056 break 13057 } 13058 { 13059 xtv, err := strconv.ParseBool(string(val)) 13060 if err != nil { 13061 return fmt.Errorf("expected DeleteMarker to be of type *bool, got %T instead", val) 13062 } 13063 sv.DeleteMarker = xtv 13064 } 13065 13066 case strings.EqualFold("DeleteMarkerVersionId", t.Name.Local): 13067 val, err := decoder.Value() 13068 if err != nil { 13069 return err 13070 } 13071 if val == nil { 13072 break 13073 } 13074 { 13075 xtv := string(val) 13076 sv.DeleteMarkerVersionId = ptr.String(xtv) 13077 } 13078 13079 case strings.EqualFold("Key", t.Name.Local): 13080 val, err := decoder.Value() 13081 if err != nil { 13082 return err 13083 } 13084 if val == nil { 13085 break 13086 } 13087 { 13088 xtv := string(val) 13089 sv.Key = ptr.String(xtv) 13090 } 13091 13092 case strings.EqualFold("VersionId", t.Name.Local): 13093 val, err := decoder.Value() 13094 if err != nil { 13095 return err 13096 } 13097 if val == nil { 13098 break 13099 } 13100 { 13101 xtv := string(val) 13102 sv.VersionId = ptr.String(xtv) 13103 } 13104 13105 default: 13106 // Do nothing and ignore the unexpected tag element 13107 err = decoder.Decoder.Skip() 13108 if err != nil { 13109 return err 13110 } 13111 13112 } 13113 decoder = originalDecoder 13114 } 13115 *v = sv 13116 return nil 13117} 13118 13119func awsRestxml_deserializeDocumentDeletedObjects(v *[]types.DeletedObject, decoder smithyxml.NodeDecoder) error { 13120 if v == nil { 13121 return fmt.Errorf("unexpected nil of type %T", v) 13122 } 13123 var sv []types.DeletedObject 13124 if *v == nil { 13125 sv = make([]types.DeletedObject, 0) 13126 } else { 13127 sv = *v 13128 } 13129 13130 originalDecoder := decoder 13131 for { 13132 t, done, err := decoder.Token() 13133 if err != nil { 13134 return err 13135 } 13136 if done { 13137 break 13138 } 13139 switch { 13140 case strings.EqualFold("member", t.Name.Local): 13141 var col types.DeletedObject 13142 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13143 destAddr := &col 13144 if err := awsRestxml_deserializeDocumentDeletedObject(&destAddr, nodeDecoder); err != nil { 13145 return err 13146 } 13147 col = *destAddr 13148 sv = append(sv, col) 13149 13150 default: 13151 err = decoder.Decoder.Skip() 13152 if err != nil { 13153 return err 13154 } 13155 13156 } 13157 decoder = originalDecoder 13158 } 13159 *v = sv 13160 return nil 13161} 13162 13163func awsRestxml_deserializeDocumentDeletedObjectsUnwrapped(v *[]types.DeletedObject, decoder smithyxml.NodeDecoder) error { 13164 var sv []types.DeletedObject 13165 if *v == nil { 13166 sv = make([]types.DeletedObject, 0) 13167 } else { 13168 sv = *v 13169 } 13170 13171 switch { 13172 default: 13173 var mv types.DeletedObject 13174 t := decoder.StartEl 13175 _ = t 13176 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13177 destAddr := &mv 13178 if err := awsRestxml_deserializeDocumentDeletedObject(&destAddr, nodeDecoder); err != nil { 13179 return err 13180 } 13181 mv = *destAddr 13182 sv = append(sv, mv) 13183 } 13184 *v = sv 13185 return nil 13186} 13187func awsRestxml_deserializeDocumentDeleteMarkerEntry(v **types.DeleteMarkerEntry, decoder smithyxml.NodeDecoder) error { 13188 if v == nil { 13189 return fmt.Errorf("unexpected nil of type %T", v) 13190 } 13191 var sv *types.DeleteMarkerEntry 13192 if *v == nil { 13193 sv = &types.DeleteMarkerEntry{} 13194 } else { 13195 sv = *v 13196 } 13197 13198 for { 13199 t, done, err := decoder.Token() 13200 if err != nil { 13201 return err 13202 } 13203 if done { 13204 break 13205 } 13206 originalDecoder := decoder 13207 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13208 switch { 13209 case strings.EqualFold("IsLatest", t.Name.Local): 13210 val, err := decoder.Value() 13211 if err != nil { 13212 return err 13213 } 13214 if val == nil { 13215 break 13216 } 13217 { 13218 xtv, err := strconv.ParseBool(string(val)) 13219 if err != nil { 13220 return fmt.Errorf("expected IsLatest to be of type *bool, got %T instead", val) 13221 } 13222 sv.IsLatest = xtv 13223 } 13224 13225 case strings.EqualFold("Key", t.Name.Local): 13226 val, err := decoder.Value() 13227 if err != nil { 13228 return err 13229 } 13230 if val == nil { 13231 break 13232 } 13233 { 13234 xtv := string(val) 13235 sv.Key = ptr.String(xtv) 13236 } 13237 13238 case strings.EqualFold("LastModified", t.Name.Local): 13239 val, err := decoder.Value() 13240 if err != nil { 13241 return err 13242 } 13243 if val == nil { 13244 break 13245 } 13246 { 13247 xtv := string(val) 13248 t, err := smithytime.ParseDateTime(xtv) 13249 if err != nil { 13250 return err 13251 } 13252 sv.LastModified = ptr.Time(t) 13253 } 13254 13255 case strings.EqualFold("Owner", t.Name.Local): 13256 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13257 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 13258 return err 13259 } 13260 13261 case strings.EqualFold("VersionId", t.Name.Local): 13262 val, err := decoder.Value() 13263 if err != nil { 13264 return err 13265 } 13266 if val == nil { 13267 break 13268 } 13269 { 13270 xtv := string(val) 13271 sv.VersionId = ptr.String(xtv) 13272 } 13273 13274 default: 13275 // Do nothing and ignore the unexpected tag element 13276 err = decoder.Decoder.Skip() 13277 if err != nil { 13278 return err 13279 } 13280 13281 } 13282 decoder = originalDecoder 13283 } 13284 *v = sv 13285 return nil 13286} 13287 13288func awsRestxml_deserializeDocumentDeleteMarkerReplication(v **types.DeleteMarkerReplication, decoder smithyxml.NodeDecoder) error { 13289 if v == nil { 13290 return fmt.Errorf("unexpected nil of type %T", v) 13291 } 13292 var sv *types.DeleteMarkerReplication 13293 if *v == nil { 13294 sv = &types.DeleteMarkerReplication{} 13295 } else { 13296 sv = *v 13297 } 13298 13299 for { 13300 t, done, err := decoder.Token() 13301 if err != nil { 13302 return err 13303 } 13304 if done { 13305 break 13306 } 13307 originalDecoder := decoder 13308 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13309 switch { 13310 case strings.EqualFold("Status", t.Name.Local): 13311 val, err := decoder.Value() 13312 if err != nil { 13313 return err 13314 } 13315 if val == nil { 13316 break 13317 } 13318 { 13319 xtv := string(val) 13320 sv.Status = types.DeleteMarkerReplicationStatus(xtv) 13321 } 13322 13323 default: 13324 // Do nothing and ignore the unexpected tag element 13325 err = decoder.Decoder.Skip() 13326 if err != nil { 13327 return err 13328 } 13329 13330 } 13331 decoder = originalDecoder 13332 } 13333 *v = sv 13334 return nil 13335} 13336 13337func awsRestxml_deserializeDocumentDeleteMarkers(v *[]types.DeleteMarkerEntry, decoder smithyxml.NodeDecoder) error { 13338 if v == nil { 13339 return fmt.Errorf("unexpected nil of type %T", v) 13340 } 13341 var sv []types.DeleteMarkerEntry 13342 if *v == nil { 13343 sv = make([]types.DeleteMarkerEntry, 0) 13344 } else { 13345 sv = *v 13346 } 13347 13348 originalDecoder := decoder 13349 for { 13350 t, done, err := decoder.Token() 13351 if err != nil { 13352 return err 13353 } 13354 if done { 13355 break 13356 } 13357 switch { 13358 case strings.EqualFold("member", t.Name.Local): 13359 var col types.DeleteMarkerEntry 13360 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13361 destAddr := &col 13362 if err := awsRestxml_deserializeDocumentDeleteMarkerEntry(&destAddr, nodeDecoder); err != nil { 13363 return err 13364 } 13365 col = *destAddr 13366 sv = append(sv, col) 13367 13368 default: 13369 err = decoder.Decoder.Skip() 13370 if err != nil { 13371 return err 13372 } 13373 13374 } 13375 decoder = originalDecoder 13376 } 13377 *v = sv 13378 return nil 13379} 13380 13381func awsRestxml_deserializeDocumentDeleteMarkersUnwrapped(v *[]types.DeleteMarkerEntry, decoder smithyxml.NodeDecoder) error { 13382 var sv []types.DeleteMarkerEntry 13383 if *v == nil { 13384 sv = make([]types.DeleteMarkerEntry, 0) 13385 } else { 13386 sv = *v 13387 } 13388 13389 switch { 13390 default: 13391 var mv types.DeleteMarkerEntry 13392 t := decoder.StartEl 13393 _ = t 13394 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13395 destAddr := &mv 13396 if err := awsRestxml_deserializeDocumentDeleteMarkerEntry(&destAddr, nodeDecoder); err != nil { 13397 return err 13398 } 13399 mv = *destAddr 13400 sv = append(sv, mv) 13401 } 13402 *v = sv 13403 return nil 13404} 13405func awsRestxml_deserializeDocumentDestination(v **types.Destination, decoder smithyxml.NodeDecoder) error { 13406 if v == nil { 13407 return fmt.Errorf("unexpected nil of type %T", v) 13408 } 13409 var sv *types.Destination 13410 if *v == nil { 13411 sv = &types.Destination{} 13412 } else { 13413 sv = *v 13414 } 13415 13416 for { 13417 t, done, err := decoder.Token() 13418 if err != nil { 13419 return err 13420 } 13421 if done { 13422 break 13423 } 13424 originalDecoder := decoder 13425 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13426 switch { 13427 case strings.EqualFold("AccessControlTranslation", t.Name.Local): 13428 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13429 if err := awsRestxml_deserializeDocumentAccessControlTranslation(&sv.AccessControlTranslation, nodeDecoder); err != nil { 13430 return err 13431 } 13432 13433 case strings.EqualFold("Account", t.Name.Local): 13434 val, err := decoder.Value() 13435 if err != nil { 13436 return err 13437 } 13438 if val == nil { 13439 break 13440 } 13441 { 13442 xtv := string(val) 13443 sv.Account = ptr.String(xtv) 13444 } 13445 13446 case strings.EqualFold("Bucket", t.Name.Local): 13447 val, err := decoder.Value() 13448 if err != nil { 13449 return err 13450 } 13451 if val == nil { 13452 break 13453 } 13454 { 13455 xtv := string(val) 13456 sv.Bucket = ptr.String(xtv) 13457 } 13458 13459 case strings.EqualFold("EncryptionConfiguration", t.Name.Local): 13460 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13461 if err := awsRestxml_deserializeDocumentEncryptionConfiguration(&sv.EncryptionConfiguration, nodeDecoder); err != nil { 13462 return err 13463 } 13464 13465 case strings.EqualFold("Metrics", t.Name.Local): 13466 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13467 if err := awsRestxml_deserializeDocumentMetrics(&sv.Metrics, nodeDecoder); err != nil { 13468 return err 13469 } 13470 13471 case strings.EqualFold("ReplicationTime", t.Name.Local): 13472 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13473 if err := awsRestxml_deserializeDocumentReplicationTime(&sv.ReplicationTime, nodeDecoder); err != nil { 13474 return err 13475 } 13476 13477 case strings.EqualFold("StorageClass", t.Name.Local): 13478 val, err := decoder.Value() 13479 if err != nil { 13480 return err 13481 } 13482 if val == nil { 13483 break 13484 } 13485 { 13486 xtv := string(val) 13487 sv.StorageClass = types.StorageClass(xtv) 13488 } 13489 13490 default: 13491 // Do nothing and ignore the unexpected tag element 13492 err = decoder.Decoder.Skip() 13493 if err != nil { 13494 return err 13495 } 13496 13497 } 13498 decoder = originalDecoder 13499 } 13500 *v = sv 13501 return nil 13502} 13503 13504func awsRestxml_deserializeDocumentEncryptionConfiguration(v **types.EncryptionConfiguration, decoder smithyxml.NodeDecoder) error { 13505 if v == nil { 13506 return fmt.Errorf("unexpected nil of type %T", v) 13507 } 13508 var sv *types.EncryptionConfiguration 13509 if *v == nil { 13510 sv = &types.EncryptionConfiguration{} 13511 } else { 13512 sv = *v 13513 } 13514 13515 for { 13516 t, done, err := decoder.Token() 13517 if err != nil { 13518 return err 13519 } 13520 if done { 13521 break 13522 } 13523 originalDecoder := decoder 13524 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13525 switch { 13526 case strings.EqualFold("ReplicaKmsKeyID", t.Name.Local): 13527 val, err := decoder.Value() 13528 if err != nil { 13529 return err 13530 } 13531 if val == nil { 13532 break 13533 } 13534 { 13535 xtv := string(val) 13536 sv.ReplicaKmsKeyID = ptr.String(xtv) 13537 } 13538 13539 default: 13540 // Do nothing and ignore the unexpected tag element 13541 err = decoder.Decoder.Skip() 13542 if err != nil { 13543 return err 13544 } 13545 13546 } 13547 decoder = originalDecoder 13548 } 13549 *v = sv 13550 return nil 13551} 13552 13553func awsRestxml_deserializeDocumentError(v **types.Error, decoder smithyxml.NodeDecoder) error { 13554 if v == nil { 13555 return fmt.Errorf("unexpected nil of type %T", v) 13556 } 13557 var sv *types.Error 13558 if *v == nil { 13559 sv = &types.Error{} 13560 } else { 13561 sv = *v 13562 } 13563 13564 for { 13565 t, done, err := decoder.Token() 13566 if err != nil { 13567 return err 13568 } 13569 if done { 13570 break 13571 } 13572 originalDecoder := decoder 13573 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13574 switch { 13575 case strings.EqualFold("Code", t.Name.Local): 13576 val, err := decoder.Value() 13577 if err != nil { 13578 return err 13579 } 13580 if val == nil { 13581 break 13582 } 13583 { 13584 xtv := string(val) 13585 sv.Code = ptr.String(xtv) 13586 } 13587 13588 case strings.EqualFold("Key", t.Name.Local): 13589 val, err := decoder.Value() 13590 if err != nil { 13591 return err 13592 } 13593 if val == nil { 13594 break 13595 } 13596 { 13597 xtv := string(val) 13598 sv.Key = ptr.String(xtv) 13599 } 13600 13601 case strings.EqualFold("Message", t.Name.Local): 13602 val, err := decoder.Value() 13603 if err != nil { 13604 return err 13605 } 13606 if val == nil { 13607 break 13608 } 13609 { 13610 xtv := string(val) 13611 sv.Message = ptr.String(xtv) 13612 } 13613 13614 case strings.EqualFold("VersionId", t.Name.Local): 13615 val, err := decoder.Value() 13616 if err != nil { 13617 return err 13618 } 13619 if val == nil { 13620 break 13621 } 13622 { 13623 xtv := string(val) 13624 sv.VersionId = ptr.String(xtv) 13625 } 13626 13627 default: 13628 // Do nothing and ignore the unexpected tag element 13629 err = decoder.Decoder.Skip() 13630 if err != nil { 13631 return err 13632 } 13633 13634 } 13635 decoder = originalDecoder 13636 } 13637 *v = sv 13638 return nil 13639} 13640 13641func awsRestxml_deserializeDocumentErrorDocument(v **types.ErrorDocument, decoder smithyxml.NodeDecoder) error { 13642 if v == nil { 13643 return fmt.Errorf("unexpected nil of type %T", v) 13644 } 13645 var sv *types.ErrorDocument 13646 if *v == nil { 13647 sv = &types.ErrorDocument{} 13648 } else { 13649 sv = *v 13650 } 13651 13652 for { 13653 t, done, err := decoder.Token() 13654 if err != nil { 13655 return err 13656 } 13657 if done { 13658 break 13659 } 13660 originalDecoder := decoder 13661 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13662 switch { 13663 case strings.EqualFold("Key", t.Name.Local): 13664 val, err := decoder.Value() 13665 if err != nil { 13666 return err 13667 } 13668 if val == nil { 13669 break 13670 } 13671 { 13672 xtv := string(val) 13673 sv.Key = ptr.String(xtv) 13674 } 13675 13676 default: 13677 // Do nothing and ignore the unexpected tag element 13678 err = decoder.Decoder.Skip() 13679 if err != nil { 13680 return err 13681 } 13682 13683 } 13684 decoder = originalDecoder 13685 } 13686 *v = sv 13687 return nil 13688} 13689 13690func awsRestxml_deserializeDocumentErrors(v *[]types.Error, decoder smithyxml.NodeDecoder) error { 13691 if v == nil { 13692 return fmt.Errorf("unexpected nil of type %T", v) 13693 } 13694 var sv []types.Error 13695 if *v == nil { 13696 sv = make([]types.Error, 0) 13697 } else { 13698 sv = *v 13699 } 13700 13701 originalDecoder := decoder 13702 for { 13703 t, done, err := decoder.Token() 13704 if err != nil { 13705 return err 13706 } 13707 if done { 13708 break 13709 } 13710 switch { 13711 case strings.EqualFold("member", t.Name.Local): 13712 var col types.Error 13713 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13714 destAddr := &col 13715 if err := awsRestxml_deserializeDocumentError(&destAddr, nodeDecoder); err != nil { 13716 return err 13717 } 13718 col = *destAddr 13719 sv = append(sv, col) 13720 13721 default: 13722 err = decoder.Decoder.Skip() 13723 if err != nil { 13724 return err 13725 } 13726 13727 } 13728 decoder = originalDecoder 13729 } 13730 *v = sv 13731 return nil 13732} 13733 13734func awsRestxml_deserializeDocumentErrorsUnwrapped(v *[]types.Error, decoder smithyxml.NodeDecoder) error { 13735 var sv []types.Error 13736 if *v == nil { 13737 sv = make([]types.Error, 0) 13738 } else { 13739 sv = *v 13740 } 13741 13742 switch { 13743 default: 13744 var mv types.Error 13745 t := decoder.StartEl 13746 _ = t 13747 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13748 destAddr := &mv 13749 if err := awsRestxml_deserializeDocumentError(&destAddr, nodeDecoder); err != nil { 13750 return err 13751 } 13752 mv = *destAddr 13753 sv = append(sv, mv) 13754 } 13755 *v = sv 13756 return nil 13757} 13758func awsRestxml_deserializeDocumentEventList(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 13759 if v == nil { 13760 return fmt.Errorf("unexpected nil of type %T", v) 13761 } 13762 var sv []types.Event 13763 if *v == nil { 13764 sv = make([]types.Event, 0) 13765 } else { 13766 sv = *v 13767 } 13768 13769 originalDecoder := decoder 13770 for { 13771 t, done, err := decoder.Token() 13772 if err != nil { 13773 return err 13774 } 13775 if done { 13776 break 13777 } 13778 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13779 decoder = memberDecoder 13780 switch { 13781 case strings.EqualFold("member", t.Name.Local): 13782 var col types.Event 13783 val, err := decoder.Value() 13784 if err != nil { 13785 return err 13786 } 13787 if val == nil { 13788 break 13789 } 13790 { 13791 xtv := string(val) 13792 col = types.Event(xtv) 13793 } 13794 sv = append(sv, col) 13795 13796 default: 13797 err = decoder.Decoder.Skip() 13798 if err != nil { 13799 return err 13800 } 13801 13802 } 13803 decoder = originalDecoder 13804 } 13805 *v = sv 13806 return nil 13807} 13808 13809func awsRestxml_deserializeDocumentEventListUnwrapped(v *[]types.Event, decoder smithyxml.NodeDecoder) error { 13810 var sv []types.Event 13811 if *v == nil { 13812 sv = make([]types.Event, 0) 13813 } else { 13814 sv = *v 13815 } 13816 13817 switch { 13818 default: 13819 var mv types.Event 13820 t := decoder.StartEl 13821 _ = t 13822 val, err := decoder.Value() 13823 if err != nil { 13824 return err 13825 } 13826 if val == nil { 13827 break 13828 } 13829 { 13830 xtv := string(val) 13831 mv = types.Event(xtv) 13832 } 13833 sv = append(sv, mv) 13834 } 13835 *v = sv 13836 return nil 13837} 13838func awsRestxml_deserializeDocumentExistingObjectReplication(v **types.ExistingObjectReplication, decoder smithyxml.NodeDecoder) error { 13839 if v == nil { 13840 return fmt.Errorf("unexpected nil of type %T", v) 13841 } 13842 var sv *types.ExistingObjectReplication 13843 if *v == nil { 13844 sv = &types.ExistingObjectReplication{} 13845 } else { 13846 sv = *v 13847 } 13848 13849 for { 13850 t, done, err := decoder.Token() 13851 if err != nil { 13852 return err 13853 } 13854 if done { 13855 break 13856 } 13857 originalDecoder := decoder 13858 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13859 switch { 13860 case strings.EqualFold("Status", t.Name.Local): 13861 val, err := decoder.Value() 13862 if err != nil { 13863 return err 13864 } 13865 if val == nil { 13866 break 13867 } 13868 { 13869 xtv := string(val) 13870 sv.Status = types.ExistingObjectReplicationStatus(xtv) 13871 } 13872 13873 default: 13874 // Do nothing and ignore the unexpected tag element 13875 err = decoder.Decoder.Skip() 13876 if err != nil { 13877 return err 13878 } 13879 13880 } 13881 decoder = originalDecoder 13882 } 13883 *v = sv 13884 return nil 13885} 13886 13887func awsRestxml_deserializeDocumentExposeHeaders(v *[]string, decoder smithyxml.NodeDecoder) error { 13888 if v == nil { 13889 return fmt.Errorf("unexpected nil of type %T", v) 13890 } 13891 var sv []string 13892 if *v == nil { 13893 sv = make([]string, 0) 13894 } else { 13895 sv = *v 13896 } 13897 13898 originalDecoder := decoder 13899 for { 13900 t, done, err := decoder.Token() 13901 if err != nil { 13902 return err 13903 } 13904 if done { 13905 break 13906 } 13907 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 13908 decoder = memberDecoder 13909 switch { 13910 case strings.EqualFold("member", t.Name.Local): 13911 var col string 13912 val, err := decoder.Value() 13913 if err != nil { 13914 return err 13915 } 13916 if val == nil { 13917 break 13918 } 13919 { 13920 xtv := string(val) 13921 col = xtv 13922 } 13923 sv = append(sv, col) 13924 13925 default: 13926 err = decoder.Decoder.Skip() 13927 if err != nil { 13928 return err 13929 } 13930 13931 } 13932 decoder = originalDecoder 13933 } 13934 *v = sv 13935 return nil 13936} 13937 13938func awsRestxml_deserializeDocumentExposeHeadersUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error { 13939 var sv []string 13940 if *v == nil { 13941 sv = make([]string, 0) 13942 } else { 13943 sv = *v 13944 } 13945 13946 switch { 13947 default: 13948 var mv string 13949 t := decoder.StartEl 13950 _ = t 13951 val, err := decoder.Value() 13952 if err != nil { 13953 return err 13954 } 13955 if val == nil { 13956 break 13957 } 13958 { 13959 xtv := string(val) 13960 mv = xtv 13961 } 13962 sv = append(sv, mv) 13963 } 13964 *v = sv 13965 return nil 13966} 13967func awsRestxml_deserializeDocumentFilterRule(v **types.FilterRule, decoder smithyxml.NodeDecoder) error { 13968 if v == nil { 13969 return fmt.Errorf("unexpected nil of type %T", v) 13970 } 13971 var sv *types.FilterRule 13972 if *v == nil { 13973 sv = &types.FilterRule{} 13974 } else { 13975 sv = *v 13976 } 13977 13978 for { 13979 t, done, err := decoder.Token() 13980 if err != nil { 13981 return err 13982 } 13983 if done { 13984 break 13985 } 13986 originalDecoder := decoder 13987 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 13988 switch { 13989 case strings.EqualFold("Name", t.Name.Local): 13990 val, err := decoder.Value() 13991 if err != nil { 13992 return err 13993 } 13994 if val == nil { 13995 break 13996 } 13997 { 13998 xtv := string(val) 13999 sv.Name = types.FilterRuleName(xtv) 14000 } 14001 14002 case strings.EqualFold("Value", t.Name.Local): 14003 val, err := decoder.Value() 14004 if err != nil { 14005 return err 14006 } 14007 if val == nil { 14008 break 14009 } 14010 { 14011 xtv := string(val) 14012 sv.Value = ptr.String(xtv) 14013 } 14014 14015 default: 14016 // Do nothing and ignore the unexpected tag element 14017 err = decoder.Decoder.Skip() 14018 if err != nil { 14019 return err 14020 } 14021 14022 } 14023 decoder = originalDecoder 14024 } 14025 *v = sv 14026 return nil 14027} 14028 14029func awsRestxml_deserializeDocumentFilterRuleList(v *[]types.FilterRule, decoder smithyxml.NodeDecoder) error { 14030 if v == nil { 14031 return fmt.Errorf("unexpected nil of type %T", v) 14032 } 14033 var sv []types.FilterRule 14034 if *v == nil { 14035 sv = make([]types.FilterRule, 0) 14036 } else { 14037 sv = *v 14038 } 14039 14040 originalDecoder := decoder 14041 for { 14042 t, done, err := decoder.Token() 14043 if err != nil { 14044 return err 14045 } 14046 if done { 14047 break 14048 } 14049 switch { 14050 case strings.EqualFold("member", t.Name.Local): 14051 var col types.FilterRule 14052 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14053 destAddr := &col 14054 if err := awsRestxml_deserializeDocumentFilterRule(&destAddr, nodeDecoder); err != nil { 14055 return err 14056 } 14057 col = *destAddr 14058 sv = append(sv, col) 14059 14060 default: 14061 err = decoder.Decoder.Skip() 14062 if err != nil { 14063 return err 14064 } 14065 14066 } 14067 decoder = originalDecoder 14068 } 14069 *v = sv 14070 return nil 14071} 14072 14073func awsRestxml_deserializeDocumentFilterRuleListUnwrapped(v *[]types.FilterRule, decoder smithyxml.NodeDecoder) error { 14074 var sv []types.FilterRule 14075 if *v == nil { 14076 sv = make([]types.FilterRule, 0) 14077 } else { 14078 sv = *v 14079 } 14080 14081 switch { 14082 default: 14083 var mv types.FilterRule 14084 t := decoder.StartEl 14085 _ = t 14086 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14087 destAddr := &mv 14088 if err := awsRestxml_deserializeDocumentFilterRule(&destAddr, nodeDecoder); err != nil { 14089 return err 14090 } 14091 mv = *destAddr 14092 sv = append(sv, mv) 14093 } 14094 *v = sv 14095 return nil 14096} 14097func awsRestxml_deserializeDocumentGrant(v **types.Grant, decoder smithyxml.NodeDecoder) error { 14098 if v == nil { 14099 return fmt.Errorf("unexpected nil of type %T", v) 14100 } 14101 var sv *types.Grant 14102 if *v == nil { 14103 sv = &types.Grant{} 14104 } else { 14105 sv = *v 14106 } 14107 14108 for { 14109 t, done, err := decoder.Token() 14110 if err != nil { 14111 return err 14112 } 14113 if done { 14114 break 14115 } 14116 originalDecoder := decoder 14117 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14118 switch { 14119 case strings.EqualFold("Grantee", t.Name.Local): 14120 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14121 if err := awsRestxml_deserializeDocumentGrantee(&sv.Grantee, nodeDecoder); err != nil { 14122 return err 14123 } 14124 14125 case strings.EqualFold("Permission", t.Name.Local): 14126 val, err := decoder.Value() 14127 if err != nil { 14128 return err 14129 } 14130 if val == nil { 14131 break 14132 } 14133 { 14134 xtv := string(val) 14135 sv.Permission = types.Permission(xtv) 14136 } 14137 14138 default: 14139 // Do nothing and ignore the unexpected tag element 14140 err = decoder.Decoder.Skip() 14141 if err != nil { 14142 return err 14143 } 14144 14145 } 14146 decoder = originalDecoder 14147 } 14148 *v = sv 14149 return nil 14150} 14151 14152func awsRestxml_deserializeDocumentGrantee(v **types.Grantee, decoder smithyxml.NodeDecoder) error { 14153 if v == nil { 14154 return fmt.Errorf("unexpected nil of type %T", v) 14155 } 14156 var sv *types.Grantee 14157 if *v == nil { 14158 sv = &types.Grantee{} 14159 } else { 14160 sv = *v 14161 } 14162 14163 for _, attr := range decoder.StartEl.Attr { 14164 name := attr.Name.Local 14165 if len(attr.Name.Space) != 0 { 14166 name = attr.Name.Space + `:` + attr.Name.Local 14167 } 14168 switch { 14169 case strings.EqualFold("xsi:type", name): 14170 val := []byte(attr.Value) 14171 { 14172 xtv := string(val) 14173 sv.Type = types.Type(xtv) 14174 } 14175 14176 } 14177 } 14178 for { 14179 t, done, err := decoder.Token() 14180 if err != nil { 14181 return err 14182 } 14183 if done { 14184 break 14185 } 14186 originalDecoder := decoder 14187 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14188 switch { 14189 case strings.EqualFold("DisplayName", t.Name.Local): 14190 val, err := decoder.Value() 14191 if err != nil { 14192 return err 14193 } 14194 if val == nil { 14195 break 14196 } 14197 { 14198 xtv := string(val) 14199 sv.DisplayName = ptr.String(xtv) 14200 } 14201 14202 case strings.EqualFold("EmailAddress", t.Name.Local): 14203 val, err := decoder.Value() 14204 if err != nil { 14205 return err 14206 } 14207 if val == nil { 14208 break 14209 } 14210 { 14211 xtv := string(val) 14212 sv.EmailAddress = ptr.String(xtv) 14213 } 14214 14215 case strings.EqualFold("ID", t.Name.Local): 14216 val, err := decoder.Value() 14217 if err != nil { 14218 return err 14219 } 14220 if val == nil { 14221 break 14222 } 14223 { 14224 xtv := string(val) 14225 sv.ID = ptr.String(xtv) 14226 } 14227 14228 case strings.EqualFold("URI", t.Name.Local): 14229 val, err := decoder.Value() 14230 if err != nil { 14231 return err 14232 } 14233 if val == nil { 14234 break 14235 } 14236 { 14237 xtv := string(val) 14238 sv.URI = ptr.String(xtv) 14239 } 14240 14241 default: 14242 // Do nothing and ignore the unexpected tag element 14243 err = decoder.Decoder.Skip() 14244 if err != nil { 14245 return err 14246 } 14247 14248 } 14249 decoder = originalDecoder 14250 } 14251 *v = sv 14252 return nil 14253} 14254 14255func awsRestxml_deserializeDocumentGrants(v *[]types.Grant, decoder smithyxml.NodeDecoder) error { 14256 if v == nil { 14257 return fmt.Errorf("unexpected nil of type %T", v) 14258 } 14259 var sv []types.Grant 14260 if *v == nil { 14261 sv = make([]types.Grant, 0) 14262 } else { 14263 sv = *v 14264 } 14265 14266 originalDecoder := decoder 14267 for { 14268 t, done, err := decoder.Token() 14269 if err != nil { 14270 return err 14271 } 14272 if done { 14273 break 14274 } 14275 switch { 14276 case strings.EqualFold("Grant", t.Name.Local): 14277 var col types.Grant 14278 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14279 destAddr := &col 14280 if err := awsRestxml_deserializeDocumentGrant(&destAddr, nodeDecoder); err != nil { 14281 return err 14282 } 14283 col = *destAddr 14284 sv = append(sv, col) 14285 14286 default: 14287 err = decoder.Decoder.Skip() 14288 if err != nil { 14289 return err 14290 } 14291 14292 } 14293 decoder = originalDecoder 14294 } 14295 *v = sv 14296 return nil 14297} 14298 14299func awsRestxml_deserializeDocumentGrantsUnwrapped(v *[]types.Grant, decoder smithyxml.NodeDecoder) error { 14300 var sv []types.Grant 14301 if *v == nil { 14302 sv = make([]types.Grant, 0) 14303 } else { 14304 sv = *v 14305 } 14306 14307 switch { 14308 default: 14309 var mv types.Grant 14310 t := decoder.StartEl 14311 _ = t 14312 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14313 destAddr := &mv 14314 if err := awsRestxml_deserializeDocumentGrant(&destAddr, nodeDecoder); err != nil { 14315 return err 14316 } 14317 mv = *destAddr 14318 sv = append(sv, mv) 14319 } 14320 *v = sv 14321 return nil 14322} 14323func awsRestxml_deserializeDocumentIndexDocument(v **types.IndexDocument, decoder smithyxml.NodeDecoder) error { 14324 if v == nil { 14325 return fmt.Errorf("unexpected nil of type %T", v) 14326 } 14327 var sv *types.IndexDocument 14328 if *v == nil { 14329 sv = &types.IndexDocument{} 14330 } else { 14331 sv = *v 14332 } 14333 14334 for { 14335 t, done, err := decoder.Token() 14336 if err != nil { 14337 return err 14338 } 14339 if done { 14340 break 14341 } 14342 originalDecoder := decoder 14343 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14344 switch { 14345 case strings.EqualFold("Suffix", t.Name.Local): 14346 val, err := decoder.Value() 14347 if err != nil { 14348 return err 14349 } 14350 if val == nil { 14351 break 14352 } 14353 { 14354 xtv := string(val) 14355 sv.Suffix = ptr.String(xtv) 14356 } 14357 14358 default: 14359 // Do nothing and ignore the unexpected tag element 14360 err = decoder.Decoder.Skip() 14361 if err != nil { 14362 return err 14363 } 14364 14365 } 14366 decoder = originalDecoder 14367 } 14368 *v = sv 14369 return nil 14370} 14371 14372func awsRestxml_deserializeDocumentInitiator(v **types.Initiator, decoder smithyxml.NodeDecoder) error { 14373 if v == nil { 14374 return fmt.Errorf("unexpected nil of type %T", v) 14375 } 14376 var sv *types.Initiator 14377 if *v == nil { 14378 sv = &types.Initiator{} 14379 } else { 14380 sv = *v 14381 } 14382 14383 for { 14384 t, done, err := decoder.Token() 14385 if err != nil { 14386 return err 14387 } 14388 if done { 14389 break 14390 } 14391 originalDecoder := decoder 14392 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14393 switch { 14394 case strings.EqualFold("DisplayName", t.Name.Local): 14395 val, err := decoder.Value() 14396 if err != nil { 14397 return err 14398 } 14399 if val == nil { 14400 break 14401 } 14402 { 14403 xtv := string(val) 14404 sv.DisplayName = ptr.String(xtv) 14405 } 14406 14407 case strings.EqualFold("ID", t.Name.Local): 14408 val, err := decoder.Value() 14409 if err != nil { 14410 return err 14411 } 14412 if val == nil { 14413 break 14414 } 14415 { 14416 xtv := string(val) 14417 sv.ID = ptr.String(xtv) 14418 } 14419 14420 default: 14421 // Do nothing and ignore the unexpected tag element 14422 err = decoder.Decoder.Skip() 14423 if err != nil { 14424 return err 14425 } 14426 14427 } 14428 decoder = originalDecoder 14429 } 14430 *v = sv 14431 return nil 14432} 14433 14434func awsRestxml_deserializeDocumentIntelligentTieringAndOperator(v **types.IntelligentTieringAndOperator, decoder smithyxml.NodeDecoder) error { 14435 if v == nil { 14436 return fmt.Errorf("unexpected nil of type %T", v) 14437 } 14438 var sv *types.IntelligentTieringAndOperator 14439 if *v == nil { 14440 sv = &types.IntelligentTieringAndOperator{} 14441 } else { 14442 sv = *v 14443 } 14444 14445 for { 14446 t, done, err := decoder.Token() 14447 if err != nil { 14448 return err 14449 } 14450 if done { 14451 break 14452 } 14453 originalDecoder := decoder 14454 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14455 switch { 14456 case strings.EqualFold("Prefix", t.Name.Local): 14457 val, err := decoder.Value() 14458 if err != nil { 14459 return err 14460 } 14461 if val == nil { 14462 break 14463 } 14464 { 14465 xtv := string(val) 14466 sv.Prefix = ptr.String(xtv) 14467 } 14468 14469 case strings.EqualFold("Tag", t.Name.Local): 14470 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14471 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 14472 return err 14473 } 14474 14475 default: 14476 // Do nothing and ignore the unexpected tag element 14477 err = decoder.Decoder.Skip() 14478 if err != nil { 14479 return err 14480 } 14481 14482 } 14483 decoder = originalDecoder 14484 } 14485 *v = sv 14486 return nil 14487} 14488 14489func awsRestxml_deserializeDocumentIntelligentTieringConfiguration(v **types.IntelligentTieringConfiguration, decoder smithyxml.NodeDecoder) error { 14490 if v == nil { 14491 return fmt.Errorf("unexpected nil of type %T", v) 14492 } 14493 var sv *types.IntelligentTieringConfiguration 14494 if *v == nil { 14495 sv = &types.IntelligentTieringConfiguration{} 14496 } else { 14497 sv = *v 14498 } 14499 14500 for { 14501 t, done, err := decoder.Token() 14502 if err != nil { 14503 return err 14504 } 14505 if done { 14506 break 14507 } 14508 originalDecoder := decoder 14509 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14510 switch { 14511 case strings.EqualFold("Filter", t.Name.Local): 14512 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14513 if err := awsRestxml_deserializeDocumentIntelligentTieringFilter(&sv.Filter, nodeDecoder); err != nil { 14514 return err 14515 } 14516 14517 case strings.EqualFold("Id", t.Name.Local): 14518 val, err := decoder.Value() 14519 if err != nil { 14520 return err 14521 } 14522 if val == nil { 14523 break 14524 } 14525 { 14526 xtv := string(val) 14527 sv.Id = ptr.String(xtv) 14528 } 14529 14530 case strings.EqualFold("Status", t.Name.Local): 14531 val, err := decoder.Value() 14532 if err != nil { 14533 return err 14534 } 14535 if val == nil { 14536 break 14537 } 14538 { 14539 xtv := string(val) 14540 sv.Status = types.IntelligentTieringStatus(xtv) 14541 } 14542 14543 case strings.EqualFold("Tiering", t.Name.Local): 14544 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14545 if err := awsRestxml_deserializeDocumentTieringListUnwrapped(&sv.Tierings, nodeDecoder); err != nil { 14546 return err 14547 } 14548 14549 default: 14550 // Do nothing and ignore the unexpected tag element 14551 err = decoder.Decoder.Skip() 14552 if err != nil { 14553 return err 14554 } 14555 14556 } 14557 decoder = originalDecoder 14558 } 14559 *v = sv 14560 return nil 14561} 14562 14563func awsRestxml_deserializeDocumentIntelligentTieringConfigurationList(v *[]types.IntelligentTieringConfiguration, decoder smithyxml.NodeDecoder) error { 14564 if v == nil { 14565 return fmt.Errorf("unexpected nil of type %T", v) 14566 } 14567 var sv []types.IntelligentTieringConfiguration 14568 if *v == nil { 14569 sv = make([]types.IntelligentTieringConfiguration, 0) 14570 } else { 14571 sv = *v 14572 } 14573 14574 originalDecoder := decoder 14575 for { 14576 t, done, err := decoder.Token() 14577 if err != nil { 14578 return err 14579 } 14580 if done { 14581 break 14582 } 14583 switch { 14584 case strings.EqualFold("member", t.Name.Local): 14585 var col types.IntelligentTieringConfiguration 14586 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14587 destAddr := &col 14588 if err := awsRestxml_deserializeDocumentIntelligentTieringConfiguration(&destAddr, nodeDecoder); err != nil { 14589 return err 14590 } 14591 col = *destAddr 14592 sv = append(sv, col) 14593 14594 default: 14595 err = decoder.Decoder.Skip() 14596 if err != nil { 14597 return err 14598 } 14599 14600 } 14601 decoder = originalDecoder 14602 } 14603 *v = sv 14604 return nil 14605} 14606 14607func awsRestxml_deserializeDocumentIntelligentTieringConfigurationListUnwrapped(v *[]types.IntelligentTieringConfiguration, decoder smithyxml.NodeDecoder) error { 14608 var sv []types.IntelligentTieringConfiguration 14609 if *v == nil { 14610 sv = make([]types.IntelligentTieringConfiguration, 0) 14611 } else { 14612 sv = *v 14613 } 14614 14615 switch { 14616 default: 14617 var mv types.IntelligentTieringConfiguration 14618 t := decoder.StartEl 14619 _ = t 14620 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14621 destAddr := &mv 14622 if err := awsRestxml_deserializeDocumentIntelligentTieringConfiguration(&destAddr, nodeDecoder); err != nil { 14623 return err 14624 } 14625 mv = *destAddr 14626 sv = append(sv, mv) 14627 } 14628 *v = sv 14629 return nil 14630} 14631func awsRestxml_deserializeDocumentIntelligentTieringFilter(v **types.IntelligentTieringFilter, decoder smithyxml.NodeDecoder) error { 14632 if v == nil { 14633 return fmt.Errorf("unexpected nil of type %T", v) 14634 } 14635 var sv *types.IntelligentTieringFilter 14636 if *v == nil { 14637 sv = &types.IntelligentTieringFilter{} 14638 } else { 14639 sv = *v 14640 } 14641 14642 for { 14643 t, done, err := decoder.Token() 14644 if err != nil { 14645 return err 14646 } 14647 if done { 14648 break 14649 } 14650 originalDecoder := decoder 14651 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14652 switch { 14653 case strings.EqualFold("And", t.Name.Local): 14654 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14655 if err := awsRestxml_deserializeDocumentIntelligentTieringAndOperator(&sv.And, nodeDecoder); err != nil { 14656 return err 14657 } 14658 14659 case strings.EqualFold("Prefix", t.Name.Local): 14660 val, err := decoder.Value() 14661 if err != nil { 14662 return err 14663 } 14664 if val == nil { 14665 break 14666 } 14667 { 14668 xtv := string(val) 14669 sv.Prefix = ptr.String(xtv) 14670 } 14671 14672 case strings.EqualFold("Tag", t.Name.Local): 14673 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14674 if err := awsRestxml_deserializeDocumentTag(&sv.Tag, nodeDecoder); err != nil { 14675 return err 14676 } 14677 14678 default: 14679 // Do nothing and ignore the unexpected tag element 14680 err = decoder.Decoder.Skip() 14681 if err != nil { 14682 return err 14683 } 14684 14685 } 14686 decoder = originalDecoder 14687 } 14688 *v = sv 14689 return nil 14690} 14691 14692func awsRestxml_deserializeDocumentInvalidObjectState(v **types.InvalidObjectState, decoder smithyxml.NodeDecoder) error { 14693 if v == nil { 14694 return fmt.Errorf("unexpected nil of type %T", v) 14695 } 14696 var sv *types.InvalidObjectState 14697 if *v == nil { 14698 sv = &types.InvalidObjectState{} 14699 } else { 14700 sv = *v 14701 } 14702 14703 for { 14704 t, done, err := decoder.Token() 14705 if err != nil { 14706 return err 14707 } 14708 if done { 14709 break 14710 } 14711 originalDecoder := decoder 14712 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14713 switch { 14714 case strings.EqualFold("AccessTier", t.Name.Local): 14715 val, err := decoder.Value() 14716 if err != nil { 14717 return err 14718 } 14719 if val == nil { 14720 break 14721 } 14722 { 14723 xtv := string(val) 14724 sv.AccessTier = types.IntelligentTieringAccessTier(xtv) 14725 } 14726 14727 case strings.EqualFold("StorageClass", t.Name.Local): 14728 val, err := decoder.Value() 14729 if err != nil { 14730 return err 14731 } 14732 if val == nil { 14733 break 14734 } 14735 { 14736 xtv := string(val) 14737 sv.StorageClass = types.StorageClass(xtv) 14738 } 14739 14740 default: 14741 // Do nothing and ignore the unexpected tag element 14742 err = decoder.Decoder.Skip() 14743 if err != nil { 14744 return err 14745 } 14746 14747 } 14748 decoder = originalDecoder 14749 } 14750 *v = sv 14751 return nil 14752} 14753 14754func awsRestxml_deserializeDocumentInventoryConfiguration(v **types.InventoryConfiguration, decoder smithyxml.NodeDecoder) error { 14755 if v == nil { 14756 return fmt.Errorf("unexpected nil of type %T", v) 14757 } 14758 var sv *types.InventoryConfiguration 14759 if *v == nil { 14760 sv = &types.InventoryConfiguration{} 14761 } else { 14762 sv = *v 14763 } 14764 14765 for { 14766 t, done, err := decoder.Token() 14767 if err != nil { 14768 return err 14769 } 14770 if done { 14771 break 14772 } 14773 originalDecoder := decoder 14774 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14775 switch { 14776 case strings.EqualFold("Destination", t.Name.Local): 14777 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14778 if err := awsRestxml_deserializeDocumentInventoryDestination(&sv.Destination, nodeDecoder); err != nil { 14779 return err 14780 } 14781 14782 case strings.EqualFold("Filter", t.Name.Local): 14783 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14784 if err := awsRestxml_deserializeDocumentInventoryFilter(&sv.Filter, nodeDecoder); err != nil { 14785 return err 14786 } 14787 14788 case strings.EqualFold("Id", t.Name.Local): 14789 val, err := decoder.Value() 14790 if err != nil { 14791 return err 14792 } 14793 if val == nil { 14794 break 14795 } 14796 { 14797 xtv := string(val) 14798 sv.Id = ptr.String(xtv) 14799 } 14800 14801 case strings.EqualFold("IncludedObjectVersions", t.Name.Local): 14802 val, err := decoder.Value() 14803 if err != nil { 14804 return err 14805 } 14806 if val == nil { 14807 break 14808 } 14809 { 14810 xtv := string(val) 14811 sv.IncludedObjectVersions = types.InventoryIncludedObjectVersions(xtv) 14812 } 14813 14814 case strings.EqualFold("IsEnabled", t.Name.Local): 14815 val, err := decoder.Value() 14816 if err != nil { 14817 return err 14818 } 14819 if val == nil { 14820 break 14821 } 14822 { 14823 xtv, err := strconv.ParseBool(string(val)) 14824 if err != nil { 14825 return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val) 14826 } 14827 sv.IsEnabled = xtv 14828 } 14829 14830 case strings.EqualFold("OptionalFields", t.Name.Local): 14831 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14832 if err := awsRestxml_deserializeDocumentInventoryOptionalFields(&sv.OptionalFields, nodeDecoder); err != nil { 14833 return err 14834 } 14835 14836 case strings.EqualFold("Schedule", t.Name.Local): 14837 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14838 if err := awsRestxml_deserializeDocumentInventorySchedule(&sv.Schedule, nodeDecoder); err != nil { 14839 return err 14840 } 14841 14842 default: 14843 // Do nothing and ignore the unexpected tag element 14844 err = decoder.Decoder.Skip() 14845 if err != nil { 14846 return err 14847 } 14848 14849 } 14850 decoder = originalDecoder 14851 } 14852 *v = sv 14853 return nil 14854} 14855 14856func awsRestxml_deserializeDocumentInventoryConfigurationList(v *[]types.InventoryConfiguration, decoder smithyxml.NodeDecoder) error { 14857 if v == nil { 14858 return fmt.Errorf("unexpected nil of type %T", v) 14859 } 14860 var sv []types.InventoryConfiguration 14861 if *v == nil { 14862 sv = make([]types.InventoryConfiguration, 0) 14863 } else { 14864 sv = *v 14865 } 14866 14867 originalDecoder := decoder 14868 for { 14869 t, done, err := decoder.Token() 14870 if err != nil { 14871 return err 14872 } 14873 if done { 14874 break 14875 } 14876 switch { 14877 case strings.EqualFold("member", t.Name.Local): 14878 var col types.InventoryConfiguration 14879 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14880 destAddr := &col 14881 if err := awsRestxml_deserializeDocumentInventoryConfiguration(&destAddr, nodeDecoder); err != nil { 14882 return err 14883 } 14884 col = *destAddr 14885 sv = append(sv, col) 14886 14887 default: 14888 err = decoder.Decoder.Skip() 14889 if err != nil { 14890 return err 14891 } 14892 14893 } 14894 decoder = originalDecoder 14895 } 14896 *v = sv 14897 return nil 14898} 14899 14900func awsRestxml_deserializeDocumentInventoryConfigurationListUnwrapped(v *[]types.InventoryConfiguration, decoder smithyxml.NodeDecoder) error { 14901 var sv []types.InventoryConfiguration 14902 if *v == nil { 14903 sv = make([]types.InventoryConfiguration, 0) 14904 } else { 14905 sv = *v 14906 } 14907 14908 switch { 14909 default: 14910 var mv types.InventoryConfiguration 14911 t := decoder.StartEl 14912 _ = t 14913 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14914 destAddr := &mv 14915 if err := awsRestxml_deserializeDocumentInventoryConfiguration(&destAddr, nodeDecoder); err != nil { 14916 return err 14917 } 14918 mv = *destAddr 14919 sv = append(sv, mv) 14920 } 14921 *v = sv 14922 return nil 14923} 14924func awsRestxml_deserializeDocumentInventoryDestination(v **types.InventoryDestination, decoder smithyxml.NodeDecoder) error { 14925 if v == nil { 14926 return fmt.Errorf("unexpected nil of type %T", v) 14927 } 14928 var sv *types.InventoryDestination 14929 if *v == nil { 14930 sv = &types.InventoryDestination{} 14931 } else { 14932 sv = *v 14933 } 14934 14935 for { 14936 t, done, err := decoder.Token() 14937 if err != nil { 14938 return err 14939 } 14940 if done { 14941 break 14942 } 14943 originalDecoder := decoder 14944 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14945 switch { 14946 case strings.EqualFold("S3BucketDestination", t.Name.Local): 14947 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14948 if err := awsRestxml_deserializeDocumentInventoryS3BucketDestination(&sv.S3BucketDestination, nodeDecoder); err != nil { 14949 return err 14950 } 14951 14952 default: 14953 // Do nothing and ignore the unexpected tag element 14954 err = decoder.Decoder.Skip() 14955 if err != nil { 14956 return err 14957 } 14958 14959 } 14960 decoder = originalDecoder 14961 } 14962 *v = sv 14963 return nil 14964} 14965 14966func awsRestxml_deserializeDocumentInventoryEncryption(v **types.InventoryEncryption, decoder smithyxml.NodeDecoder) error { 14967 if v == nil { 14968 return fmt.Errorf("unexpected nil of type %T", v) 14969 } 14970 var sv *types.InventoryEncryption 14971 if *v == nil { 14972 sv = &types.InventoryEncryption{} 14973 } else { 14974 sv = *v 14975 } 14976 14977 for { 14978 t, done, err := decoder.Token() 14979 if err != nil { 14980 return err 14981 } 14982 if done { 14983 break 14984 } 14985 originalDecoder := decoder 14986 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 14987 switch { 14988 case strings.EqualFold("SSE-KMS", t.Name.Local): 14989 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14990 if err := awsRestxml_deserializeDocumentSSEKMS(&sv.SSEKMS, nodeDecoder); err != nil { 14991 return err 14992 } 14993 14994 case strings.EqualFold("SSE-S3", t.Name.Local): 14995 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 14996 if err := awsRestxml_deserializeDocumentSSES3(&sv.SSES3, nodeDecoder); err != nil { 14997 return err 14998 } 14999 15000 default: 15001 // Do nothing and ignore the unexpected tag element 15002 err = decoder.Decoder.Skip() 15003 if err != nil { 15004 return err 15005 } 15006 15007 } 15008 decoder = originalDecoder 15009 } 15010 *v = sv 15011 return nil 15012} 15013 15014func awsRestxml_deserializeDocumentInventoryFilter(v **types.InventoryFilter, decoder smithyxml.NodeDecoder) error { 15015 if v == nil { 15016 return fmt.Errorf("unexpected nil of type %T", v) 15017 } 15018 var sv *types.InventoryFilter 15019 if *v == nil { 15020 sv = &types.InventoryFilter{} 15021 } else { 15022 sv = *v 15023 } 15024 15025 for { 15026 t, done, err := decoder.Token() 15027 if err != nil { 15028 return err 15029 } 15030 if done { 15031 break 15032 } 15033 originalDecoder := decoder 15034 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15035 switch { 15036 case strings.EqualFold("Prefix", t.Name.Local): 15037 val, err := decoder.Value() 15038 if err != nil { 15039 return err 15040 } 15041 if val == nil { 15042 break 15043 } 15044 { 15045 xtv := string(val) 15046 sv.Prefix = ptr.String(xtv) 15047 } 15048 15049 default: 15050 // Do nothing and ignore the unexpected tag element 15051 err = decoder.Decoder.Skip() 15052 if err != nil { 15053 return err 15054 } 15055 15056 } 15057 decoder = originalDecoder 15058 } 15059 *v = sv 15060 return nil 15061} 15062 15063func awsRestxml_deserializeDocumentInventoryOptionalFields(v *[]types.InventoryOptionalField, decoder smithyxml.NodeDecoder) error { 15064 if v == nil { 15065 return fmt.Errorf("unexpected nil of type %T", v) 15066 } 15067 var sv []types.InventoryOptionalField 15068 if *v == nil { 15069 sv = make([]types.InventoryOptionalField, 0) 15070 } else { 15071 sv = *v 15072 } 15073 15074 originalDecoder := decoder 15075 for { 15076 t, done, err := decoder.Token() 15077 if err != nil { 15078 return err 15079 } 15080 if done { 15081 break 15082 } 15083 memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15084 decoder = memberDecoder 15085 switch { 15086 case strings.EqualFold("Field", t.Name.Local): 15087 var col types.InventoryOptionalField 15088 val, err := decoder.Value() 15089 if err != nil { 15090 return err 15091 } 15092 if val == nil { 15093 break 15094 } 15095 { 15096 xtv := string(val) 15097 col = types.InventoryOptionalField(xtv) 15098 } 15099 sv = append(sv, col) 15100 15101 default: 15102 err = decoder.Decoder.Skip() 15103 if err != nil { 15104 return err 15105 } 15106 15107 } 15108 decoder = originalDecoder 15109 } 15110 *v = sv 15111 return nil 15112} 15113 15114func awsRestxml_deserializeDocumentInventoryOptionalFieldsUnwrapped(v *[]types.InventoryOptionalField, decoder smithyxml.NodeDecoder) error { 15115 var sv []types.InventoryOptionalField 15116 if *v == nil { 15117 sv = make([]types.InventoryOptionalField, 0) 15118 } else { 15119 sv = *v 15120 } 15121 15122 switch { 15123 default: 15124 var mv types.InventoryOptionalField 15125 t := decoder.StartEl 15126 _ = t 15127 val, err := decoder.Value() 15128 if err != nil { 15129 return err 15130 } 15131 if val == nil { 15132 break 15133 } 15134 { 15135 xtv := string(val) 15136 mv = types.InventoryOptionalField(xtv) 15137 } 15138 sv = append(sv, mv) 15139 } 15140 *v = sv 15141 return nil 15142} 15143func awsRestxml_deserializeDocumentInventoryS3BucketDestination(v **types.InventoryS3BucketDestination, decoder smithyxml.NodeDecoder) error { 15144 if v == nil { 15145 return fmt.Errorf("unexpected nil of type %T", v) 15146 } 15147 var sv *types.InventoryS3BucketDestination 15148 if *v == nil { 15149 sv = &types.InventoryS3BucketDestination{} 15150 } else { 15151 sv = *v 15152 } 15153 15154 for { 15155 t, done, err := decoder.Token() 15156 if err != nil { 15157 return err 15158 } 15159 if done { 15160 break 15161 } 15162 originalDecoder := decoder 15163 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15164 switch { 15165 case strings.EqualFold("AccountId", t.Name.Local): 15166 val, err := decoder.Value() 15167 if err != nil { 15168 return err 15169 } 15170 if val == nil { 15171 break 15172 } 15173 { 15174 xtv := string(val) 15175 sv.AccountId = ptr.String(xtv) 15176 } 15177 15178 case strings.EqualFold("Bucket", t.Name.Local): 15179 val, err := decoder.Value() 15180 if err != nil { 15181 return err 15182 } 15183 if val == nil { 15184 break 15185 } 15186 { 15187 xtv := string(val) 15188 sv.Bucket = ptr.String(xtv) 15189 } 15190 15191 case strings.EqualFold("Encryption", t.Name.Local): 15192 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15193 if err := awsRestxml_deserializeDocumentInventoryEncryption(&sv.Encryption, nodeDecoder); err != nil { 15194 return err 15195 } 15196 15197 case strings.EqualFold("Format", t.Name.Local): 15198 val, err := decoder.Value() 15199 if err != nil { 15200 return err 15201 } 15202 if val == nil { 15203 break 15204 } 15205 { 15206 xtv := string(val) 15207 sv.Format = types.InventoryFormat(xtv) 15208 } 15209 15210 case strings.EqualFold("Prefix", t.Name.Local): 15211 val, err := decoder.Value() 15212 if err != nil { 15213 return err 15214 } 15215 if val == nil { 15216 break 15217 } 15218 { 15219 xtv := string(val) 15220 sv.Prefix = ptr.String(xtv) 15221 } 15222 15223 default: 15224 // Do nothing and ignore the unexpected tag element 15225 err = decoder.Decoder.Skip() 15226 if err != nil { 15227 return err 15228 } 15229 15230 } 15231 decoder = originalDecoder 15232 } 15233 *v = sv 15234 return nil 15235} 15236 15237func awsRestxml_deserializeDocumentInventorySchedule(v **types.InventorySchedule, decoder smithyxml.NodeDecoder) error { 15238 if v == nil { 15239 return fmt.Errorf("unexpected nil of type %T", v) 15240 } 15241 var sv *types.InventorySchedule 15242 if *v == nil { 15243 sv = &types.InventorySchedule{} 15244 } else { 15245 sv = *v 15246 } 15247 15248 for { 15249 t, done, err := decoder.Token() 15250 if err != nil { 15251 return err 15252 } 15253 if done { 15254 break 15255 } 15256 originalDecoder := decoder 15257 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15258 switch { 15259 case strings.EqualFold("Frequency", t.Name.Local): 15260 val, err := decoder.Value() 15261 if err != nil { 15262 return err 15263 } 15264 if val == nil { 15265 break 15266 } 15267 { 15268 xtv := string(val) 15269 sv.Frequency = types.InventoryFrequency(xtv) 15270 } 15271 15272 default: 15273 // Do nothing and ignore the unexpected tag element 15274 err = decoder.Decoder.Skip() 15275 if err != nil { 15276 return err 15277 } 15278 15279 } 15280 decoder = originalDecoder 15281 } 15282 *v = sv 15283 return nil 15284} 15285 15286func awsRestxml_deserializeDocumentLambdaFunctionConfiguration(v **types.LambdaFunctionConfiguration, decoder smithyxml.NodeDecoder) error { 15287 if v == nil { 15288 return fmt.Errorf("unexpected nil of type %T", v) 15289 } 15290 var sv *types.LambdaFunctionConfiguration 15291 if *v == nil { 15292 sv = &types.LambdaFunctionConfiguration{} 15293 } else { 15294 sv = *v 15295 } 15296 15297 for { 15298 t, done, err := decoder.Token() 15299 if err != nil { 15300 return err 15301 } 15302 if done { 15303 break 15304 } 15305 originalDecoder := decoder 15306 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15307 switch { 15308 case strings.EqualFold("Event", t.Name.Local): 15309 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15310 if err := awsRestxml_deserializeDocumentEventListUnwrapped(&sv.Events, nodeDecoder); err != nil { 15311 return err 15312 } 15313 15314 case strings.EqualFold("Filter", t.Name.Local): 15315 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15316 if err := awsRestxml_deserializeDocumentNotificationConfigurationFilter(&sv.Filter, nodeDecoder); err != nil { 15317 return err 15318 } 15319 15320 case strings.EqualFold("Id", t.Name.Local): 15321 val, err := decoder.Value() 15322 if err != nil { 15323 return err 15324 } 15325 if val == nil { 15326 break 15327 } 15328 { 15329 xtv := string(val) 15330 sv.Id = ptr.String(xtv) 15331 } 15332 15333 case strings.EqualFold("CloudFunction", t.Name.Local): 15334 val, err := decoder.Value() 15335 if err != nil { 15336 return err 15337 } 15338 if val == nil { 15339 break 15340 } 15341 { 15342 xtv := string(val) 15343 sv.LambdaFunctionArn = ptr.String(xtv) 15344 } 15345 15346 default: 15347 // Do nothing and ignore the unexpected tag element 15348 err = decoder.Decoder.Skip() 15349 if err != nil { 15350 return err 15351 } 15352 15353 } 15354 decoder = originalDecoder 15355 } 15356 *v = sv 15357 return nil 15358} 15359 15360func awsRestxml_deserializeDocumentLambdaFunctionConfigurationList(v *[]types.LambdaFunctionConfiguration, decoder smithyxml.NodeDecoder) error { 15361 if v == nil { 15362 return fmt.Errorf("unexpected nil of type %T", v) 15363 } 15364 var sv []types.LambdaFunctionConfiguration 15365 if *v == nil { 15366 sv = make([]types.LambdaFunctionConfiguration, 0) 15367 } else { 15368 sv = *v 15369 } 15370 15371 originalDecoder := decoder 15372 for { 15373 t, done, err := decoder.Token() 15374 if err != nil { 15375 return err 15376 } 15377 if done { 15378 break 15379 } 15380 switch { 15381 case strings.EqualFold("member", t.Name.Local): 15382 var col types.LambdaFunctionConfiguration 15383 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15384 destAddr := &col 15385 if err := awsRestxml_deserializeDocumentLambdaFunctionConfiguration(&destAddr, nodeDecoder); err != nil { 15386 return err 15387 } 15388 col = *destAddr 15389 sv = append(sv, col) 15390 15391 default: 15392 err = decoder.Decoder.Skip() 15393 if err != nil { 15394 return err 15395 } 15396 15397 } 15398 decoder = originalDecoder 15399 } 15400 *v = sv 15401 return nil 15402} 15403 15404func awsRestxml_deserializeDocumentLambdaFunctionConfigurationListUnwrapped(v *[]types.LambdaFunctionConfiguration, decoder smithyxml.NodeDecoder) error { 15405 var sv []types.LambdaFunctionConfiguration 15406 if *v == nil { 15407 sv = make([]types.LambdaFunctionConfiguration, 0) 15408 } else { 15409 sv = *v 15410 } 15411 15412 switch { 15413 default: 15414 var mv types.LambdaFunctionConfiguration 15415 t := decoder.StartEl 15416 _ = t 15417 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15418 destAddr := &mv 15419 if err := awsRestxml_deserializeDocumentLambdaFunctionConfiguration(&destAddr, nodeDecoder); err != nil { 15420 return err 15421 } 15422 mv = *destAddr 15423 sv = append(sv, mv) 15424 } 15425 *v = sv 15426 return nil 15427} 15428func awsRestxml_deserializeDocumentLifecycleExpiration(v **types.LifecycleExpiration, decoder smithyxml.NodeDecoder) error { 15429 if v == nil { 15430 return fmt.Errorf("unexpected nil of type %T", v) 15431 } 15432 var sv *types.LifecycleExpiration 15433 if *v == nil { 15434 sv = &types.LifecycleExpiration{} 15435 } else { 15436 sv = *v 15437 } 15438 15439 for { 15440 t, done, err := decoder.Token() 15441 if err != nil { 15442 return err 15443 } 15444 if done { 15445 break 15446 } 15447 originalDecoder := decoder 15448 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15449 switch { 15450 case strings.EqualFold("Date", t.Name.Local): 15451 val, err := decoder.Value() 15452 if err != nil { 15453 return err 15454 } 15455 if val == nil { 15456 break 15457 } 15458 { 15459 xtv := string(val) 15460 t, err := smithytime.ParseDateTime(xtv) 15461 if err != nil { 15462 return err 15463 } 15464 sv.Date = ptr.Time(t) 15465 } 15466 15467 case strings.EqualFold("Days", t.Name.Local): 15468 val, err := decoder.Value() 15469 if err != nil { 15470 return err 15471 } 15472 if val == nil { 15473 break 15474 } 15475 { 15476 xtv := string(val) 15477 i64, err := strconv.ParseInt(xtv, 10, 64) 15478 if err != nil { 15479 return err 15480 } 15481 sv.Days = int32(i64) 15482 } 15483 15484 case strings.EqualFold("ExpiredObjectDeleteMarker", t.Name.Local): 15485 val, err := decoder.Value() 15486 if err != nil { 15487 return err 15488 } 15489 if val == nil { 15490 break 15491 } 15492 { 15493 xtv, err := strconv.ParseBool(string(val)) 15494 if err != nil { 15495 return fmt.Errorf("expected ExpiredObjectDeleteMarker to be of type *bool, got %T instead", val) 15496 } 15497 sv.ExpiredObjectDeleteMarker = xtv 15498 } 15499 15500 default: 15501 // Do nothing and ignore the unexpected tag element 15502 err = decoder.Decoder.Skip() 15503 if err != nil { 15504 return err 15505 } 15506 15507 } 15508 decoder = originalDecoder 15509 } 15510 *v = sv 15511 return nil 15512} 15513 15514func awsRestxml_deserializeDocumentLifecycleRule(v **types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 15515 if v == nil { 15516 return fmt.Errorf("unexpected nil of type %T", v) 15517 } 15518 var sv *types.LifecycleRule 15519 if *v == nil { 15520 sv = &types.LifecycleRule{} 15521 } else { 15522 sv = *v 15523 } 15524 15525 for { 15526 t, done, err := decoder.Token() 15527 if err != nil { 15528 return err 15529 } 15530 if done { 15531 break 15532 } 15533 originalDecoder := decoder 15534 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15535 switch { 15536 case strings.EqualFold("AbortIncompleteMultipartUpload", t.Name.Local): 15537 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15538 if err := awsRestxml_deserializeDocumentAbortIncompleteMultipartUpload(&sv.AbortIncompleteMultipartUpload, nodeDecoder); err != nil { 15539 return err 15540 } 15541 15542 case strings.EqualFold("Expiration", t.Name.Local): 15543 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15544 if err := awsRestxml_deserializeDocumentLifecycleExpiration(&sv.Expiration, nodeDecoder); err != nil { 15545 return err 15546 } 15547 15548 case strings.EqualFold("Filter", t.Name.Local): 15549 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15550 if err := awsRestxml_deserializeDocumentLifecycleRuleFilter(&sv.Filter, nodeDecoder); err != nil { 15551 return err 15552 } 15553 15554 case strings.EqualFold("ID", t.Name.Local): 15555 val, err := decoder.Value() 15556 if err != nil { 15557 return err 15558 } 15559 if val == nil { 15560 break 15561 } 15562 { 15563 xtv := string(val) 15564 sv.ID = ptr.String(xtv) 15565 } 15566 15567 case strings.EqualFold("NoncurrentVersionExpiration", t.Name.Local): 15568 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15569 if err := awsRestxml_deserializeDocumentNoncurrentVersionExpiration(&sv.NoncurrentVersionExpiration, nodeDecoder); err != nil { 15570 return err 15571 } 15572 15573 case strings.EqualFold("NoncurrentVersionTransition", t.Name.Local): 15574 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15575 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransitionListUnwrapped(&sv.NoncurrentVersionTransitions, nodeDecoder); err != nil { 15576 return err 15577 } 15578 15579 case strings.EqualFold("Prefix", t.Name.Local): 15580 val, err := decoder.Value() 15581 if err != nil { 15582 return err 15583 } 15584 if val == nil { 15585 break 15586 } 15587 { 15588 xtv := string(val) 15589 sv.Prefix = ptr.String(xtv) 15590 } 15591 15592 case strings.EqualFold("Status", t.Name.Local): 15593 val, err := decoder.Value() 15594 if err != nil { 15595 return err 15596 } 15597 if val == nil { 15598 break 15599 } 15600 { 15601 xtv := string(val) 15602 sv.Status = types.ExpirationStatus(xtv) 15603 } 15604 15605 case strings.EqualFold("Transition", t.Name.Local): 15606 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15607 if err := awsRestxml_deserializeDocumentTransitionListUnwrapped(&sv.Transitions, nodeDecoder); err != nil { 15608 return err 15609 } 15610 15611 default: 15612 // Do nothing and ignore the unexpected tag element 15613 err = decoder.Decoder.Skip() 15614 if err != nil { 15615 return err 15616 } 15617 15618 } 15619 decoder = originalDecoder 15620 } 15621 *v = sv 15622 return nil 15623} 15624 15625func awsRestxml_deserializeDocumentLifecycleRuleAndOperator(v **types.LifecycleRuleAndOperator, decoder smithyxml.NodeDecoder) error { 15626 if v == nil { 15627 return fmt.Errorf("unexpected nil of type %T", v) 15628 } 15629 var sv *types.LifecycleRuleAndOperator 15630 if *v == nil { 15631 sv = &types.LifecycleRuleAndOperator{} 15632 } else { 15633 sv = *v 15634 } 15635 15636 for { 15637 t, done, err := decoder.Token() 15638 if err != nil { 15639 return err 15640 } 15641 if done { 15642 break 15643 } 15644 originalDecoder := decoder 15645 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15646 switch { 15647 case strings.EqualFold("Prefix", t.Name.Local): 15648 val, err := decoder.Value() 15649 if err != nil { 15650 return err 15651 } 15652 if val == nil { 15653 break 15654 } 15655 { 15656 xtv := string(val) 15657 sv.Prefix = ptr.String(xtv) 15658 } 15659 15660 case strings.EqualFold("Tag", t.Name.Local): 15661 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15662 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 15663 return err 15664 } 15665 15666 default: 15667 // Do nothing and ignore the unexpected tag element 15668 err = decoder.Decoder.Skip() 15669 if err != nil { 15670 return err 15671 } 15672 15673 } 15674 decoder = originalDecoder 15675 } 15676 *v = sv 15677 return nil 15678} 15679 15680func awsRestxml_deserializeDocumentLifecycleRuleFilter(v *types.LifecycleRuleFilter, decoder smithyxml.NodeDecoder) error { 15681 if v == nil { 15682 return fmt.Errorf("unexpected nil of type %T", v) 15683 } 15684 var uv types.LifecycleRuleFilter 15685 var memberFound bool 15686 for { 15687 t, done, err := decoder.Token() 15688 if err != nil { 15689 return err 15690 } 15691 if done { 15692 break 15693 } 15694 if memberFound { 15695 if err = decoder.Decoder.Skip(); err != nil { 15696 return err 15697 } 15698 } 15699 originalDecoder := decoder 15700 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15701 switch { 15702 case strings.EqualFold("And", t.Name.Local): 15703 var mv types.LifecycleRuleAndOperator 15704 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15705 destAddr := &mv 15706 if err := awsRestxml_deserializeDocumentLifecycleRuleAndOperator(&destAddr, nodeDecoder); err != nil { 15707 return err 15708 } 15709 mv = *destAddr 15710 uv = &types.LifecycleRuleFilterMemberAnd{Value: mv} 15711 memberFound = true 15712 15713 case strings.EqualFold("Prefix", t.Name.Local): 15714 var mv string 15715 val, err := decoder.Value() 15716 if err != nil { 15717 return err 15718 } 15719 if val == nil { 15720 break 15721 } 15722 { 15723 xtv := string(val) 15724 mv = xtv 15725 } 15726 uv = &types.LifecycleRuleFilterMemberPrefix{Value: mv} 15727 memberFound = true 15728 15729 case strings.EqualFold("Tag", t.Name.Local): 15730 var mv types.Tag 15731 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15732 destAddr := &mv 15733 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 15734 return err 15735 } 15736 mv = *destAddr 15737 uv = &types.LifecycleRuleFilterMemberTag{Value: mv} 15738 memberFound = true 15739 15740 default: 15741 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 15742 memberFound = true 15743 15744 } 15745 decoder = originalDecoder 15746 } 15747 *v = uv 15748 return nil 15749} 15750 15751func awsRestxml_deserializeDocumentLifecycleRules(v *[]types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 15752 if v == nil { 15753 return fmt.Errorf("unexpected nil of type %T", v) 15754 } 15755 var sv []types.LifecycleRule 15756 if *v == nil { 15757 sv = make([]types.LifecycleRule, 0) 15758 } else { 15759 sv = *v 15760 } 15761 15762 originalDecoder := decoder 15763 for { 15764 t, done, err := decoder.Token() 15765 if err != nil { 15766 return err 15767 } 15768 if done { 15769 break 15770 } 15771 switch { 15772 case strings.EqualFold("member", t.Name.Local): 15773 var col types.LifecycleRule 15774 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15775 destAddr := &col 15776 if err := awsRestxml_deserializeDocumentLifecycleRule(&destAddr, nodeDecoder); err != nil { 15777 return err 15778 } 15779 col = *destAddr 15780 sv = append(sv, col) 15781 15782 default: 15783 err = decoder.Decoder.Skip() 15784 if err != nil { 15785 return err 15786 } 15787 15788 } 15789 decoder = originalDecoder 15790 } 15791 *v = sv 15792 return nil 15793} 15794 15795func awsRestxml_deserializeDocumentLifecycleRulesUnwrapped(v *[]types.LifecycleRule, decoder smithyxml.NodeDecoder) error { 15796 var sv []types.LifecycleRule 15797 if *v == nil { 15798 sv = make([]types.LifecycleRule, 0) 15799 } else { 15800 sv = *v 15801 } 15802 15803 switch { 15804 default: 15805 var mv types.LifecycleRule 15806 t := decoder.StartEl 15807 _ = t 15808 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15809 destAddr := &mv 15810 if err := awsRestxml_deserializeDocumentLifecycleRule(&destAddr, nodeDecoder); err != nil { 15811 return err 15812 } 15813 mv = *destAddr 15814 sv = append(sv, mv) 15815 } 15816 *v = sv 15817 return nil 15818} 15819func awsRestxml_deserializeDocumentLoggingEnabled(v **types.LoggingEnabled, decoder smithyxml.NodeDecoder) error { 15820 if v == nil { 15821 return fmt.Errorf("unexpected nil of type %T", v) 15822 } 15823 var sv *types.LoggingEnabled 15824 if *v == nil { 15825 sv = &types.LoggingEnabled{} 15826 } else { 15827 sv = *v 15828 } 15829 15830 for { 15831 t, done, err := decoder.Token() 15832 if err != nil { 15833 return err 15834 } 15835 if done { 15836 break 15837 } 15838 originalDecoder := decoder 15839 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15840 switch { 15841 case strings.EqualFold("TargetBucket", t.Name.Local): 15842 val, err := decoder.Value() 15843 if err != nil { 15844 return err 15845 } 15846 if val == nil { 15847 break 15848 } 15849 { 15850 xtv := string(val) 15851 sv.TargetBucket = ptr.String(xtv) 15852 } 15853 15854 case strings.EqualFold("TargetGrants", t.Name.Local): 15855 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15856 if err := awsRestxml_deserializeDocumentTargetGrants(&sv.TargetGrants, nodeDecoder); err != nil { 15857 return err 15858 } 15859 15860 case strings.EqualFold("TargetPrefix", t.Name.Local): 15861 val, err := decoder.Value() 15862 if err != nil { 15863 return err 15864 } 15865 if val == nil { 15866 break 15867 } 15868 { 15869 xtv := string(val) 15870 sv.TargetPrefix = ptr.String(xtv) 15871 } 15872 15873 default: 15874 // Do nothing and ignore the unexpected tag element 15875 err = decoder.Decoder.Skip() 15876 if err != nil { 15877 return err 15878 } 15879 15880 } 15881 decoder = originalDecoder 15882 } 15883 *v = sv 15884 return nil 15885} 15886 15887func awsRestxml_deserializeDocumentMetrics(v **types.Metrics, decoder smithyxml.NodeDecoder) error { 15888 if v == nil { 15889 return fmt.Errorf("unexpected nil of type %T", v) 15890 } 15891 var sv *types.Metrics 15892 if *v == nil { 15893 sv = &types.Metrics{} 15894 } else { 15895 sv = *v 15896 } 15897 15898 for { 15899 t, done, err := decoder.Token() 15900 if err != nil { 15901 return err 15902 } 15903 if done { 15904 break 15905 } 15906 originalDecoder := decoder 15907 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15908 switch { 15909 case strings.EqualFold("EventThreshold", t.Name.Local): 15910 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15911 if err := awsRestxml_deserializeDocumentReplicationTimeValue(&sv.EventThreshold, nodeDecoder); err != nil { 15912 return err 15913 } 15914 15915 case strings.EqualFold("Status", t.Name.Local): 15916 val, err := decoder.Value() 15917 if err != nil { 15918 return err 15919 } 15920 if val == nil { 15921 break 15922 } 15923 { 15924 xtv := string(val) 15925 sv.Status = types.MetricsStatus(xtv) 15926 } 15927 15928 default: 15929 // Do nothing and ignore the unexpected tag element 15930 err = decoder.Decoder.Skip() 15931 if err != nil { 15932 return err 15933 } 15934 15935 } 15936 decoder = originalDecoder 15937 } 15938 *v = sv 15939 return nil 15940} 15941 15942func awsRestxml_deserializeDocumentMetricsAndOperator(v **types.MetricsAndOperator, decoder smithyxml.NodeDecoder) error { 15943 if v == nil { 15944 return fmt.Errorf("unexpected nil of type %T", v) 15945 } 15946 var sv *types.MetricsAndOperator 15947 if *v == nil { 15948 sv = &types.MetricsAndOperator{} 15949 } else { 15950 sv = *v 15951 } 15952 15953 for { 15954 t, done, err := decoder.Token() 15955 if err != nil { 15956 return err 15957 } 15958 if done { 15959 break 15960 } 15961 originalDecoder := decoder 15962 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 15963 switch { 15964 case strings.EqualFold("Prefix", t.Name.Local): 15965 val, err := decoder.Value() 15966 if err != nil { 15967 return err 15968 } 15969 if val == nil { 15970 break 15971 } 15972 { 15973 xtv := string(val) 15974 sv.Prefix = ptr.String(xtv) 15975 } 15976 15977 case strings.EqualFold("Tag", t.Name.Local): 15978 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 15979 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 15980 return err 15981 } 15982 15983 default: 15984 // Do nothing and ignore the unexpected tag element 15985 err = decoder.Decoder.Skip() 15986 if err != nil { 15987 return err 15988 } 15989 15990 } 15991 decoder = originalDecoder 15992 } 15993 *v = sv 15994 return nil 15995} 15996 15997func awsRestxml_deserializeDocumentMetricsConfiguration(v **types.MetricsConfiguration, decoder smithyxml.NodeDecoder) error { 15998 if v == nil { 15999 return fmt.Errorf("unexpected nil of type %T", v) 16000 } 16001 var sv *types.MetricsConfiguration 16002 if *v == nil { 16003 sv = &types.MetricsConfiguration{} 16004 } else { 16005 sv = *v 16006 } 16007 16008 for { 16009 t, done, err := decoder.Token() 16010 if err != nil { 16011 return err 16012 } 16013 if done { 16014 break 16015 } 16016 originalDecoder := decoder 16017 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16018 switch { 16019 case strings.EqualFold("Filter", t.Name.Local): 16020 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16021 if err := awsRestxml_deserializeDocumentMetricsFilter(&sv.Filter, nodeDecoder); err != nil { 16022 return err 16023 } 16024 16025 case strings.EqualFold("Id", t.Name.Local): 16026 val, err := decoder.Value() 16027 if err != nil { 16028 return err 16029 } 16030 if val == nil { 16031 break 16032 } 16033 { 16034 xtv := string(val) 16035 sv.Id = ptr.String(xtv) 16036 } 16037 16038 default: 16039 // Do nothing and ignore the unexpected tag element 16040 err = decoder.Decoder.Skip() 16041 if err != nil { 16042 return err 16043 } 16044 16045 } 16046 decoder = originalDecoder 16047 } 16048 *v = sv 16049 return nil 16050} 16051 16052func awsRestxml_deserializeDocumentMetricsConfigurationList(v *[]types.MetricsConfiguration, decoder smithyxml.NodeDecoder) error { 16053 if v == nil { 16054 return fmt.Errorf("unexpected nil of type %T", v) 16055 } 16056 var sv []types.MetricsConfiguration 16057 if *v == nil { 16058 sv = make([]types.MetricsConfiguration, 0) 16059 } else { 16060 sv = *v 16061 } 16062 16063 originalDecoder := decoder 16064 for { 16065 t, done, err := decoder.Token() 16066 if err != nil { 16067 return err 16068 } 16069 if done { 16070 break 16071 } 16072 switch { 16073 case strings.EqualFold("member", t.Name.Local): 16074 var col types.MetricsConfiguration 16075 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16076 destAddr := &col 16077 if err := awsRestxml_deserializeDocumentMetricsConfiguration(&destAddr, nodeDecoder); err != nil { 16078 return err 16079 } 16080 col = *destAddr 16081 sv = append(sv, col) 16082 16083 default: 16084 err = decoder.Decoder.Skip() 16085 if err != nil { 16086 return err 16087 } 16088 16089 } 16090 decoder = originalDecoder 16091 } 16092 *v = sv 16093 return nil 16094} 16095 16096func awsRestxml_deserializeDocumentMetricsConfigurationListUnwrapped(v *[]types.MetricsConfiguration, decoder smithyxml.NodeDecoder) error { 16097 var sv []types.MetricsConfiguration 16098 if *v == nil { 16099 sv = make([]types.MetricsConfiguration, 0) 16100 } else { 16101 sv = *v 16102 } 16103 16104 switch { 16105 default: 16106 var mv types.MetricsConfiguration 16107 t := decoder.StartEl 16108 _ = t 16109 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16110 destAddr := &mv 16111 if err := awsRestxml_deserializeDocumentMetricsConfiguration(&destAddr, nodeDecoder); err != nil { 16112 return err 16113 } 16114 mv = *destAddr 16115 sv = append(sv, mv) 16116 } 16117 *v = sv 16118 return nil 16119} 16120func awsRestxml_deserializeDocumentMetricsFilter(v *types.MetricsFilter, decoder smithyxml.NodeDecoder) error { 16121 if v == nil { 16122 return fmt.Errorf("unexpected nil of type %T", v) 16123 } 16124 var uv types.MetricsFilter 16125 var memberFound bool 16126 for { 16127 t, done, err := decoder.Token() 16128 if err != nil { 16129 return err 16130 } 16131 if done { 16132 break 16133 } 16134 if memberFound { 16135 if err = decoder.Decoder.Skip(); err != nil { 16136 return err 16137 } 16138 } 16139 originalDecoder := decoder 16140 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16141 switch { 16142 case strings.EqualFold("And", t.Name.Local): 16143 var mv types.MetricsAndOperator 16144 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16145 destAddr := &mv 16146 if err := awsRestxml_deserializeDocumentMetricsAndOperator(&destAddr, nodeDecoder); err != nil { 16147 return err 16148 } 16149 mv = *destAddr 16150 uv = &types.MetricsFilterMemberAnd{Value: mv} 16151 memberFound = true 16152 16153 case strings.EqualFold("Prefix", t.Name.Local): 16154 var mv string 16155 val, err := decoder.Value() 16156 if err != nil { 16157 return err 16158 } 16159 if val == nil { 16160 break 16161 } 16162 { 16163 xtv := string(val) 16164 mv = xtv 16165 } 16166 uv = &types.MetricsFilterMemberPrefix{Value: mv} 16167 memberFound = true 16168 16169 case strings.EqualFold("Tag", t.Name.Local): 16170 var mv types.Tag 16171 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16172 destAddr := &mv 16173 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 16174 return err 16175 } 16176 mv = *destAddr 16177 uv = &types.MetricsFilterMemberTag{Value: mv} 16178 memberFound = true 16179 16180 default: 16181 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 16182 memberFound = true 16183 16184 } 16185 decoder = originalDecoder 16186 } 16187 *v = uv 16188 return nil 16189} 16190 16191func awsRestxml_deserializeDocumentMultipartUpload(v **types.MultipartUpload, decoder smithyxml.NodeDecoder) error { 16192 if v == nil { 16193 return fmt.Errorf("unexpected nil of type %T", v) 16194 } 16195 var sv *types.MultipartUpload 16196 if *v == nil { 16197 sv = &types.MultipartUpload{} 16198 } else { 16199 sv = *v 16200 } 16201 16202 for { 16203 t, done, err := decoder.Token() 16204 if err != nil { 16205 return err 16206 } 16207 if done { 16208 break 16209 } 16210 originalDecoder := decoder 16211 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16212 switch { 16213 case strings.EqualFold("Initiated", t.Name.Local): 16214 val, err := decoder.Value() 16215 if err != nil { 16216 return err 16217 } 16218 if val == nil { 16219 break 16220 } 16221 { 16222 xtv := string(val) 16223 t, err := smithytime.ParseDateTime(xtv) 16224 if err != nil { 16225 return err 16226 } 16227 sv.Initiated = ptr.Time(t) 16228 } 16229 16230 case strings.EqualFold("Initiator", t.Name.Local): 16231 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16232 if err := awsRestxml_deserializeDocumentInitiator(&sv.Initiator, nodeDecoder); err != nil { 16233 return err 16234 } 16235 16236 case strings.EqualFold("Key", t.Name.Local): 16237 val, err := decoder.Value() 16238 if err != nil { 16239 return err 16240 } 16241 if val == nil { 16242 break 16243 } 16244 { 16245 xtv := string(val) 16246 sv.Key = ptr.String(xtv) 16247 } 16248 16249 case strings.EqualFold("Owner", t.Name.Local): 16250 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16251 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 16252 return err 16253 } 16254 16255 case strings.EqualFold("StorageClass", t.Name.Local): 16256 val, err := decoder.Value() 16257 if err != nil { 16258 return err 16259 } 16260 if val == nil { 16261 break 16262 } 16263 { 16264 xtv := string(val) 16265 sv.StorageClass = types.StorageClass(xtv) 16266 } 16267 16268 case strings.EqualFold("UploadId", t.Name.Local): 16269 val, err := decoder.Value() 16270 if err != nil { 16271 return err 16272 } 16273 if val == nil { 16274 break 16275 } 16276 { 16277 xtv := string(val) 16278 sv.UploadId = ptr.String(xtv) 16279 } 16280 16281 default: 16282 // Do nothing and ignore the unexpected tag element 16283 err = decoder.Decoder.Skip() 16284 if err != nil { 16285 return err 16286 } 16287 16288 } 16289 decoder = originalDecoder 16290 } 16291 *v = sv 16292 return nil 16293} 16294 16295func awsRestxml_deserializeDocumentMultipartUploadList(v *[]types.MultipartUpload, decoder smithyxml.NodeDecoder) error { 16296 if v == nil { 16297 return fmt.Errorf("unexpected nil of type %T", v) 16298 } 16299 var sv []types.MultipartUpload 16300 if *v == nil { 16301 sv = make([]types.MultipartUpload, 0) 16302 } else { 16303 sv = *v 16304 } 16305 16306 originalDecoder := decoder 16307 for { 16308 t, done, err := decoder.Token() 16309 if err != nil { 16310 return err 16311 } 16312 if done { 16313 break 16314 } 16315 switch { 16316 case strings.EqualFold("member", t.Name.Local): 16317 var col types.MultipartUpload 16318 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16319 destAddr := &col 16320 if err := awsRestxml_deserializeDocumentMultipartUpload(&destAddr, nodeDecoder); err != nil { 16321 return err 16322 } 16323 col = *destAddr 16324 sv = append(sv, col) 16325 16326 default: 16327 err = decoder.Decoder.Skip() 16328 if err != nil { 16329 return err 16330 } 16331 16332 } 16333 decoder = originalDecoder 16334 } 16335 *v = sv 16336 return nil 16337} 16338 16339func awsRestxml_deserializeDocumentMultipartUploadListUnwrapped(v *[]types.MultipartUpload, decoder smithyxml.NodeDecoder) error { 16340 var sv []types.MultipartUpload 16341 if *v == nil { 16342 sv = make([]types.MultipartUpload, 0) 16343 } else { 16344 sv = *v 16345 } 16346 16347 switch { 16348 default: 16349 var mv types.MultipartUpload 16350 t := decoder.StartEl 16351 _ = t 16352 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16353 destAddr := &mv 16354 if err := awsRestxml_deserializeDocumentMultipartUpload(&destAddr, nodeDecoder); err != nil { 16355 return err 16356 } 16357 mv = *destAddr 16358 sv = append(sv, mv) 16359 } 16360 *v = sv 16361 return nil 16362} 16363func awsRestxml_deserializeDocumentNoncurrentVersionExpiration(v **types.NoncurrentVersionExpiration, decoder smithyxml.NodeDecoder) error { 16364 if v == nil { 16365 return fmt.Errorf("unexpected nil of type %T", v) 16366 } 16367 var sv *types.NoncurrentVersionExpiration 16368 if *v == nil { 16369 sv = &types.NoncurrentVersionExpiration{} 16370 } else { 16371 sv = *v 16372 } 16373 16374 for { 16375 t, done, err := decoder.Token() 16376 if err != nil { 16377 return err 16378 } 16379 if done { 16380 break 16381 } 16382 originalDecoder := decoder 16383 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16384 switch { 16385 case strings.EqualFold("NoncurrentDays", t.Name.Local): 16386 val, err := decoder.Value() 16387 if err != nil { 16388 return err 16389 } 16390 if val == nil { 16391 break 16392 } 16393 { 16394 xtv := string(val) 16395 i64, err := strconv.ParseInt(xtv, 10, 64) 16396 if err != nil { 16397 return err 16398 } 16399 sv.NoncurrentDays = int32(i64) 16400 } 16401 16402 default: 16403 // Do nothing and ignore the unexpected tag element 16404 err = decoder.Decoder.Skip() 16405 if err != nil { 16406 return err 16407 } 16408 16409 } 16410 decoder = originalDecoder 16411 } 16412 *v = sv 16413 return nil 16414} 16415 16416func awsRestxml_deserializeDocumentNoncurrentVersionTransition(v **types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 16417 if v == nil { 16418 return fmt.Errorf("unexpected nil of type %T", v) 16419 } 16420 var sv *types.NoncurrentVersionTransition 16421 if *v == nil { 16422 sv = &types.NoncurrentVersionTransition{} 16423 } else { 16424 sv = *v 16425 } 16426 16427 for { 16428 t, done, err := decoder.Token() 16429 if err != nil { 16430 return err 16431 } 16432 if done { 16433 break 16434 } 16435 originalDecoder := decoder 16436 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16437 switch { 16438 case strings.EqualFold("NoncurrentDays", t.Name.Local): 16439 val, err := decoder.Value() 16440 if err != nil { 16441 return err 16442 } 16443 if val == nil { 16444 break 16445 } 16446 { 16447 xtv := string(val) 16448 i64, err := strconv.ParseInt(xtv, 10, 64) 16449 if err != nil { 16450 return err 16451 } 16452 sv.NoncurrentDays = int32(i64) 16453 } 16454 16455 case strings.EqualFold("StorageClass", t.Name.Local): 16456 val, err := decoder.Value() 16457 if err != nil { 16458 return err 16459 } 16460 if val == nil { 16461 break 16462 } 16463 { 16464 xtv := string(val) 16465 sv.StorageClass = types.TransitionStorageClass(xtv) 16466 } 16467 16468 default: 16469 // Do nothing and ignore the unexpected tag element 16470 err = decoder.Decoder.Skip() 16471 if err != nil { 16472 return err 16473 } 16474 16475 } 16476 decoder = originalDecoder 16477 } 16478 *v = sv 16479 return nil 16480} 16481 16482func awsRestxml_deserializeDocumentNoncurrentVersionTransitionList(v *[]types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 16483 if v == nil { 16484 return fmt.Errorf("unexpected nil of type %T", v) 16485 } 16486 var sv []types.NoncurrentVersionTransition 16487 if *v == nil { 16488 sv = make([]types.NoncurrentVersionTransition, 0) 16489 } else { 16490 sv = *v 16491 } 16492 16493 originalDecoder := decoder 16494 for { 16495 t, done, err := decoder.Token() 16496 if err != nil { 16497 return err 16498 } 16499 if done { 16500 break 16501 } 16502 switch { 16503 case strings.EqualFold("member", t.Name.Local): 16504 var col types.NoncurrentVersionTransition 16505 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16506 destAddr := &col 16507 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransition(&destAddr, nodeDecoder); err != nil { 16508 return err 16509 } 16510 col = *destAddr 16511 sv = append(sv, col) 16512 16513 default: 16514 err = decoder.Decoder.Skip() 16515 if err != nil { 16516 return err 16517 } 16518 16519 } 16520 decoder = originalDecoder 16521 } 16522 *v = sv 16523 return nil 16524} 16525 16526func awsRestxml_deserializeDocumentNoncurrentVersionTransitionListUnwrapped(v *[]types.NoncurrentVersionTransition, decoder smithyxml.NodeDecoder) error { 16527 var sv []types.NoncurrentVersionTransition 16528 if *v == nil { 16529 sv = make([]types.NoncurrentVersionTransition, 0) 16530 } else { 16531 sv = *v 16532 } 16533 16534 switch { 16535 default: 16536 var mv types.NoncurrentVersionTransition 16537 t := decoder.StartEl 16538 _ = t 16539 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16540 destAddr := &mv 16541 if err := awsRestxml_deserializeDocumentNoncurrentVersionTransition(&destAddr, nodeDecoder); err != nil { 16542 return err 16543 } 16544 mv = *destAddr 16545 sv = append(sv, mv) 16546 } 16547 *v = sv 16548 return nil 16549} 16550func awsRestxml_deserializeDocumentNoSuchBucket(v **types.NoSuchBucket, decoder smithyxml.NodeDecoder) error { 16551 if v == nil { 16552 return fmt.Errorf("unexpected nil of type %T", v) 16553 } 16554 var sv *types.NoSuchBucket 16555 if *v == nil { 16556 sv = &types.NoSuchBucket{} 16557 } else { 16558 sv = *v 16559 } 16560 16561 for { 16562 t, done, err := decoder.Token() 16563 if err != nil { 16564 return err 16565 } 16566 if done { 16567 break 16568 } 16569 originalDecoder := decoder 16570 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16571 switch { 16572 default: 16573 // Do nothing and ignore the unexpected tag element 16574 err = decoder.Decoder.Skip() 16575 if err != nil { 16576 return err 16577 } 16578 16579 } 16580 decoder = originalDecoder 16581 } 16582 *v = sv 16583 return nil 16584} 16585 16586func awsRestxml_deserializeDocumentNoSuchKey(v **types.NoSuchKey, decoder smithyxml.NodeDecoder) error { 16587 if v == nil { 16588 return fmt.Errorf("unexpected nil of type %T", v) 16589 } 16590 var sv *types.NoSuchKey 16591 if *v == nil { 16592 sv = &types.NoSuchKey{} 16593 } else { 16594 sv = *v 16595 } 16596 16597 for { 16598 t, done, err := decoder.Token() 16599 if err != nil { 16600 return err 16601 } 16602 if done { 16603 break 16604 } 16605 originalDecoder := decoder 16606 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16607 switch { 16608 default: 16609 // Do nothing and ignore the unexpected tag element 16610 err = decoder.Decoder.Skip() 16611 if err != nil { 16612 return err 16613 } 16614 16615 } 16616 decoder = originalDecoder 16617 } 16618 *v = sv 16619 return nil 16620} 16621 16622func awsRestxml_deserializeDocumentNoSuchUpload(v **types.NoSuchUpload, decoder smithyxml.NodeDecoder) error { 16623 if v == nil { 16624 return fmt.Errorf("unexpected nil of type %T", v) 16625 } 16626 var sv *types.NoSuchUpload 16627 if *v == nil { 16628 sv = &types.NoSuchUpload{} 16629 } else { 16630 sv = *v 16631 } 16632 16633 for { 16634 t, done, err := decoder.Token() 16635 if err != nil { 16636 return err 16637 } 16638 if done { 16639 break 16640 } 16641 originalDecoder := decoder 16642 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16643 switch { 16644 default: 16645 // Do nothing and ignore the unexpected tag element 16646 err = decoder.Decoder.Skip() 16647 if err != nil { 16648 return err 16649 } 16650 16651 } 16652 decoder = originalDecoder 16653 } 16654 *v = sv 16655 return nil 16656} 16657 16658func awsRestxml_deserializeDocumentNotFound(v **types.NotFound, decoder smithyxml.NodeDecoder) error { 16659 if v == nil { 16660 return fmt.Errorf("unexpected nil of type %T", v) 16661 } 16662 var sv *types.NotFound 16663 if *v == nil { 16664 sv = &types.NotFound{} 16665 } else { 16666 sv = *v 16667 } 16668 16669 for { 16670 t, done, err := decoder.Token() 16671 if err != nil { 16672 return err 16673 } 16674 if done { 16675 break 16676 } 16677 originalDecoder := decoder 16678 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16679 switch { 16680 default: 16681 // Do nothing and ignore the unexpected tag element 16682 err = decoder.Decoder.Skip() 16683 if err != nil { 16684 return err 16685 } 16686 16687 } 16688 decoder = originalDecoder 16689 } 16690 *v = sv 16691 return nil 16692} 16693 16694func awsRestxml_deserializeDocumentNotificationConfigurationFilter(v **types.NotificationConfigurationFilter, decoder smithyxml.NodeDecoder) error { 16695 if v == nil { 16696 return fmt.Errorf("unexpected nil of type %T", v) 16697 } 16698 var sv *types.NotificationConfigurationFilter 16699 if *v == nil { 16700 sv = &types.NotificationConfigurationFilter{} 16701 } else { 16702 sv = *v 16703 } 16704 16705 for { 16706 t, done, err := decoder.Token() 16707 if err != nil { 16708 return err 16709 } 16710 if done { 16711 break 16712 } 16713 originalDecoder := decoder 16714 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16715 switch { 16716 case strings.EqualFold("S3Key", t.Name.Local): 16717 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16718 if err := awsRestxml_deserializeDocumentS3KeyFilter(&sv.Key, nodeDecoder); err != nil { 16719 return err 16720 } 16721 16722 default: 16723 // Do nothing and ignore the unexpected tag element 16724 err = decoder.Decoder.Skip() 16725 if err != nil { 16726 return err 16727 } 16728 16729 } 16730 decoder = originalDecoder 16731 } 16732 *v = sv 16733 return nil 16734} 16735 16736func awsRestxml_deserializeDocumentObject(v **types.Object, decoder smithyxml.NodeDecoder) error { 16737 if v == nil { 16738 return fmt.Errorf("unexpected nil of type %T", v) 16739 } 16740 var sv *types.Object 16741 if *v == nil { 16742 sv = &types.Object{} 16743 } else { 16744 sv = *v 16745 } 16746 16747 for { 16748 t, done, err := decoder.Token() 16749 if err != nil { 16750 return err 16751 } 16752 if done { 16753 break 16754 } 16755 originalDecoder := decoder 16756 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16757 switch { 16758 case strings.EqualFold("ETag", t.Name.Local): 16759 val, err := decoder.Value() 16760 if err != nil { 16761 return err 16762 } 16763 if val == nil { 16764 break 16765 } 16766 { 16767 xtv := string(val) 16768 sv.ETag = ptr.String(xtv) 16769 } 16770 16771 case strings.EqualFold("Key", t.Name.Local): 16772 val, err := decoder.Value() 16773 if err != nil { 16774 return err 16775 } 16776 if val == nil { 16777 break 16778 } 16779 { 16780 xtv := string(val) 16781 sv.Key = ptr.String(xtv) 16782 } 16783 16784 case strings.EqualFold("LastModified", t.Name.Local): 16785 val, err := decoder.Value() 16786 if err != nil { 16787 return err 16788 } 16789 if val == nil { 16790 break 16791 } 16792 { 16793 xtv := string(val) 16794 t, err := smithytime.ParseDateTime(xtv) 16795 if err != nil { 16796 return err 16797 } 16798 sv.LastModified = ptr.Time(t) 16799 } 16800 16801 case strings.EqualFold("Owner", t.Name.Local): 16802 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16803 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 16804 return err 16805 } 16806 16807 case strings.EqualFold("Size", t.Name.Local): 16808 val, err := decoder.Value() 16809 if err != nil { 16810 return err 16811 } 16812 if val == nil { 16813 break 16814 } 16815 { 16816 xtv := string(val) 16817 i64, err := strconv.ParseInt(xtv, 10, 64) 16818 if err != nil { 16819 return err 16820 } 16821 sv.Size = i64 16822 } 16823 16824 case strings.EqualFold("StorageClass", t.Name.Local): 16825 val, err := decoder.Value() 16826 if err != nil { 16827 return err 16828 } 16829 if val == nil { 16830 break 16831 } 16832 { 16833 xtv := string(val) 16834 sv.StorageClass = types.ObjectStorageClass(xtv) 16835 } 16836 16837 default: 16838 // Do nothing and ignore the unexpected tag element 16839 err = decoder.Decoder.Skip() 16840 if err != nil { 16841 return err 16842 } 16843 16844 } 16845 decoder = originalDecoder 16846 } 16847 *v = sv 16848 return nil 16849} 16850 16851func awsRestxml_deserializeDocumentObjectAlreadyInActiveTierError(v **types.ObjectAlreadyInActiveTierError, decoder smithyxml.NodeDecoder) error { 16852 if v == nil { 16853 return fmt.Errorf("unexpected nil of type %T", v) 16854 } 16855 var sv *types.ObjectAlreadyInActiveTierError 16856 if *v == nil { 16857 sv = &types.ObjectAlreadyInActiveTierError{} 16858 } else { 16859 sv = *v 16860 } 16861 16862 for { 16863 t, done, err := decoder.Token() 16864 if err != nil { 16865 return err 16866 } 16867 if done { 16868 break 16869 } 16870 originalDecoder := decoder 16871 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16872 switch { 16873 default: 16874 // Do nothing and ignore the unexpected tag element 16875 err = decoder.Decoder.Skip() 16876 if err != nil { 16877 return err 16878 } 16879 16880 } 16881 decoder = originalDecoder 16882 } 16883 *v = sv 16884 return nil 16885} 16886 16887func awsRestxml_deserializeDocumentObjectList(v *[]types.Object, decoder smithyxml.NodeDecoder) error { 16888 if v == nil { 16889 return fmt.Errorf("unexpected nil of type %T", v) 16890 } 16891 var sv []types.Object 16892 if *v == nil { 16893 sv = make([]types.Object, 0) 16894 } else { 16895 sv = *v 16896 } 16897 16898 originalDecoder := decoder 16899 for { 16900 t, done, err := decoder.Token() 16901 if err != nil { 16902 return err 16903 } 16904 if done { 16905 break 16906 } 16907 switch { 16908 case strings.EqualFold("member", t.Name.Local): 16909 var col types.Object 16910 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16911 destAddr := &col 16912 if err := awsRestxml_deserializeDocumentObject(&destAddr, nodeDecoder); err != nil { 16913 return err 16914 } 16915 col = *destAddr 16916 sv = append(sv, col) 16917 16918 default: 16919 err = decoder.Decoder.Skip() 16920 if err != nil { 16921 return err 16922 } 16923 16924 } 16925 decoder = originalDecoder 16926 } 16927 *v = sv 16928 return nil 16929} 16930 16931func awsRestxml_deserializeDocumentObjectListUnwrapped(v *[]types.Object, decoder smithyxml.NodeDecoder) error { 16932 var sv []types.Object 16933 if *v == nil { 16934 sv = make([]types.Object, 0) 16935 } else { 16936 sv = *v 16937 } 16938 16939 switch { 16940 default: 16941 var mv types.Object 16942 t := decoder.StartEl 16943 _ = t 16944 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16945 destAddr := &mv 16946 if err := awsRestxml_deserializeDocumentObject(&destAddr, nodeDecoder); err != nil { 16947 return err 16948 } 16949 mv = *destAddr 16950 sv = append(sv, mv) 16951 } 16952 *v = sv 16953 return nil 16954} 16955func awsRestxml_deserializeDocumentObjectLockConfiguration(v **types.ObjectLockConfiguration, decoder smithyxml.NodeDecoder) error { 16956 if v == nil { 16957 return fmt.Errorf("unexpected nil of type %T", v) 16958 } 16959 var sv *types.ObjectLockConfiguration 16960 if *v == nil { 16961 sv = &types.ObjectLockConfiguration{} 16962 } else { 16963 sv = *v 16964 } 16965 16966 for { 16967 t, done, err := decoder.Token() 16968 if err != nil { 16969 return err 16970 } 16971 if done { 16972 break 16973 } 16974 originalDecoder := decoder 16975 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 16976 switch { 16977 case strings.EqualFold("ObjectLockEnabled", t.Name.Local): 16978 val, err := decoder.Value() 16979 if err != nil { 16980 return err 16981 } 16982 if val == nil { 16983 break 16984 } 16985 { 16986 xtv := string(val) 16987 sv.ObjectLockEnabled = types.ObjectLockEnabled(xtv) 16988 } 16989 16990 case strings.EqualFold("Rule", t.Name.Local): 16991 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 16992 if err := awsRestxml_deserializeDocumentObjectLockRule(&sv.Rule, nodeDecoder); err != nil { 16993 return err 16994 } 16995 16996 default: 16997 // Do nothing and ignore the unexpected tag element 16998 err = decoder.Decoder.Skip() 16999 if err != nil { 17000 return err 17001 } 17002 17003 } 17004 decoder = originalDecoder 17005 } 17006 *v = sv 17007 return nil 17008} 17009 17010func awsRestxml_deserializeDocumentObjectLockLegalHold(v **types.ObjectLockLegalHold, decoder smithyxml.NodeDecoder) error { 17011 if v == nil { 17012 return fmt.Errorf("unexpected nil of type %T", v) 17013 } 17014 var sv *types.ObjectLockLegalHold 17015 if *v == nil { 17016 sv = &types.ObjectLockLegalHold{} 17017 } else { 17018 sv = *v 17019 } 17020 17021 for { 17022 t, done, err := decoder.Token() 17023 if err != nil { 17024 return err 17025 } 17026 if done { 17027 break 17028 } 17029 originalDecoder := decoder 17030 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17031 switch { 17032 case strings.EqualFold("Status", t.Name.Local): 17033 val, err := decoder.Value() 17034 if err != nil { 17035 return err 17036 } 17037 if val == nil { 17038 break 17039 } 17040 { 17041 xtv := string(val) 17042 sv.Status = types.ObjectLockLegalHoldStatus(xtv) 17043 } 17044 17045 default: 17046 // Do nothing and ignore the unexpected tag element 17047 err = decoder.Decoder.Skip() 17048 if err != nil { 17049 return err 17050 } 17051 17052 } 17053 decoder = originalDecoder 17054 } 17055 *v = sv 17056 return nil 17057} 17058 17059func awsRestxml_deserializeDocumentObjectLockRetention(v **types.ObjectLockRetention, decoder smithyxml.NodeDecoder) error { 17060 if v == nil { 17061 return fmt.Errorf("unexpected nil of type %T", v) 17062 } 17063 var sv *types.ObjectLockRetention 17064 if *v == nil { 17065 sv = &types.ObjectLockRetention{} 17066 } else { 17067 sv = *v 17068 } 17069 17070 for { 17071 t, done, err := decoder.Token() 17072 if err != nil { 17073 return err 17074 } 17075 if done { 17076 break 17077 } 17078 originalDecoder := decoder 17079 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17080 switch { 17081 case strings.EqualFold("Mode", t.Name.Local): 17082 val, err := decoder.Value() 17083 if err != nil { 17084 return err 17085 } 17086 if val == nil { 17087 break 17088 } 17089 { 17090 xtv := string(val) 17091 sv.Mode = types.ObjectLockRetentionMode(xtv) 17092 } 17093 17094 case strings.EqualFold("RetainUntilDate", t.Name.Local): 17095 val, err := decoder.Value() 17096 if err != nil { 17097 return err 17098 } 17099 if val == nil { 17100 break 17101 } 17102 { 17103 xtv := string(val) 17104 t, err := smithytime.ParseDateTime(xtv) 17105 if err != nil { 17106 return err 17107 } 17108 sv.RetainUntilDate = ptr.Time(t) 17109 } 17110 17111 default: 17112 // Do nothing and ignore the unexpected tag element 17113 err = decoder.Decoder.Skip() 17114 if err != nil { 17115 return err 17116 } 17117 17118 } 17119 decoder = originalDecoder 17120 } 17121 *v = sv 17122 return nil 17123} 17124 17125func awsRestxml_deserializeDocumentObjectLockRule(v **types.ObjectLockRule, decoder smithyxml.NodeDecoder) error { 17126 if v == nil { 17127 return fmt.Errorf("unexpected nil of type %T", v) 17128 } 17129 var sv *types.ObjectLockRule 17130 if *v == nil { 17131 sv = &types.ObjectLockRule{} 17132 } else { 17133 sv = *v 17134 } 17135 17136 for { 17137 t, done, err := decoder.Token() 17138 if err != nil { 17139 return err 17140 } 17141 if done { 17142 break 17143 } 17144 originalDecoder := decoder 17145 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17146 switch { 17147 case strings.EqualFold("DefaultRetention", t.Name.Local): 17148 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17149 if err := awsRestxml_deserializeDocumentDefaultRetention(&sv.DefaultRetention, nodeDecoder); err != nil { 17150 return err 17151 } 17152 17153 default: 17154 // Do nothing and ignore the unexpected tag element 17155 err = decoder.Decoder.Skip() 17156 if err != nil { 17157 return err 17158 } 17159 17160 } 17161 decoder = originalDecoder 17162 } 17163 *v = sv 17164 return nil 17165} 17166 17167func awsRestxml_deserializeDocumentObjectNotInActiveTierError(v **types.ObjectNotInActiveTierError, decoder smithyxml.NodeDecoder) error { 17168 if v == nil { 17169 return fmt.Errorf("unexpected nil of type %T", v) 17170 } 17171 var sv *types.ObjectNotInActiveTierError 17172 if *v == nil { 17173 sv = &types.ObjectNotInActiveTierError{} 17174 } else { 17175 sv = *v 17176 } 17177 17178 for { 17179 t, done, err := decoder.Token() 17180 if err != nil { 17181 return err 17182 } 17183 if done { 17184 break 17185 } 17186 originalDecoder := decoder 17187 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17188 switch { 17189 default: 17190 // Do nothing and ignore the unexpected tag element 17191 err = decoder.Decoder.Skip() 17192 if err != nil { 17193 return err 17194 } 17195 17196 } 17197 decoder = originalDecoder 17198 } 17199 *v = sv 17200 return nil 17201} 17202 17203func awsRestxml_deserializeDocumentObjectVersion(v **types.ObjectVersion, decoder smithyxml.NodeDecoder) error { 17204 if v == nil { 17205 return fmt.Errorf("unexpected nil of type %T", v) 17206 } 17207 var sv *types.ObjectVersion 17208 if *v == nil { 17209 sv = &types.ObjectVersion{} 17210 } else { 17211 sv = *v 17212 } 17213 17214 for { 17215 t, done, err := decoder.Token() 17216 if err != nil { 17217 return err 17218 } 17219 if done { 17220 break 17221 } 17222 originalDecoder := decoder 17223 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17224 switch { 17225 case strings.EqualFold("ETag", t.Name.Local): 17226 val, err := decoder.Value() 17227 if err != nil { 17228 return err 17229 } 17230 if val == nil { 17231 break 17232 } 17233 { 17234 xtv := string(val) 17235 sv.ETag = ptr.String(xtv) 17236 } 17237 17238 case strings.EqualFold("IsLatest", t.Name.Local): 17239 val, err := decoder.Value() 17240 if err != nil { 17241 return err 17242 } 17243 if val == nil { 17244 break 17245 } 17246 { 17247 xtv, err := strconv.ParseBool(string(val)) 17248 if err != nil { 17249 return fmt.Errorf("expected IsLatest to be of type *bool, got %T instead", val) 17250 } 17251 sv.IsLatest = xtv 17252 } 17253 17254 case strings.EqualFold("Key", t.Name.Local): 17255 val, err := decoder.Value() 17256 if err != nil { 17257 return err 17258 } 17259 if val == nil { 17260 break 17261 } 17262 { 17263 xtv := string(val) 17264 sv.Key = ptr.String(xtv) 17265 } 17266 17267 case strings.EqualFold("LastModified", t.Name.Local): 17268 val, err := decoder.Value() 17269 if err != nil { 17270 return err 17271 } 17272 if val == nil { 17273 break 17274 } 17275 { 17276 xtv := string(val) 17277 t, err := smithytime.ParseDateTime(xtv) 17278 if err != nil { 17279 return err 17280 } 17281 sv.LastModified = ptr.Time(t) 17282 } 17283 17284 case strings.EqualFold("Owner", t.Name.Local): 17285 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17286 if err := awsRestxml_deserializeDocumentOwner(&sv.Owner, nodeDecoder); err != nil { 17287 return err 17288 } 17289 17290 case strings.EqualFold("Size", 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 i64, err := strconv.ParseInt(xtv, 10, 64) 17301 if err != nil { 17302 return err 17303 } 17304 sv.Size = i64 17305 } 17306 17307 case strings.EqualFold("StorageClass", t.Name.Local): 17308 val, err := decoder.Value() 17309 if err != nil { 17310 return err 17311 } 17312 if val == nil { 17313 break 17314 } 17315 { 17316 xtv := string(val) 17317 sv.StorageClass = types.ObjectVersionStorageClass(xtv) 17318 } 17319 17320 case strings.EqualFold("VersionId", t.Name.Local): 17321 val, err := decoder.Value() 17322 if err != nil { 17323 return err 17324 } 17325 if val == nil { 17326 break 17327 } 17328 { 17329 xtv := string(val) 17330 sv.VersionId = ptr.String(xtv) 17331 } 17332 17333 default: 17334 // Do nothing and ignore the unexpected tag element 17335 err = decoder.Decoder.Skip() 17336 if err != nil { 17337 return err 17338 } 17339 17340 } 17341 decoder = originalDecoder 17342 } 17343 *v = sv 17344 return nil 17345} 17346 17347func awsRestxml_deserializeDocumentObjectVersionList(v *[]types.ObjectVersion, decoder smithyxml.NodeDecoder) error { 17348 if v == nil { 17349 return fmt.Errorf("unexpected nil of type %T", v) 17350 } 17351 var sv []types.ObjectVersion 17352 if *v == nil { 17353 sv = make([]types.ObjectVersion, 0) 17354 } else { 17355 sv = *v 17356 } 17357 17358 originalDecoder := decoder 17359 for { 17360 t, done, err := decoder.Token() 17361 if err != nil { 17362 return err 17363 } 17364 if done { 17365 break 17366 } 17367 switch { 17368 case strings.EqualFold("member", t.Name.Local): 17369 var col types.ObjectVersion 17370 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17371 destAddr := &col 17372 if err := awsRestxml_deserializeDocumentObjectVersion(&destAddr, nodeDecoder); err != nil { 17373 return err 17374 } 17375 col = *destAddr 17376 sv = append(sv, col) 17377 17378 default: 17379 err = decoder.Decoder.Skip() 17380 if err != nil { 17381 return err 17382 } 17383 17384 } 17385 decoder = originalDecoder 17386 } 17387 *v = sv 17388 return nil 17389} 17390 17391func awsRestxml_deserializeDocumentObjectVersionListUnwrapped(v *[]types.ObjectVersion, decoder smithyxml.NodeDecoder) error { 17392 var sv []types.ObjectVersion 17393 if *v == nil { 17394 sv = make([]types.ObjectVersion, 0) 17395 } else { 17396 sv = *v 17397 } 17398 17399 switch { 17400 default: 17401 var mv types.ObjectVersion 17402 t := decoder.StartEl 17403 _ = t 17404 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17405 destAddr := &mv 17406 if err := awsRestxml_deserializeDocumentObjectVersion(&destAddr, nodeDecoder); err != nil { 17407 return err 17408 } 17409 mv = *destAddr 17410 sv = append(sv, mv) 17411 } 17412 *v = sv 17413 return nil 17414} 17415func awsRestxml_deserializeDocumentOwner(v **types.Owner, decoder smithyxml.NodeDecoder) error { 17416 if v == nil { 17417 return fmt.Errorf("unexpected nil of type %T", v) 17418 } 17419 var sv *types.Owner 17420 if *v == nil { 17421 sv = &types.Owner{} 17422 } else { 17423 sv = *v 17424 } 17425 17426 for { 17427 t, done, err := decoder.Token() 17428 if err != nil { 17429 return err 17430 } 17431 if done { 17432 break 17433 } 17434 originalDecoder := decoder 17435 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17436 switch { 17437 case strings.EqualFold("DisplayName", t.Name.Local): 17438 val, err := decoder.Value() 17439 if err != nil { 17440 return err 17441 } 17442 if val == nil { 17443 break 17444 } 17445 { 17446 xtv := string(val) 17447 sv.DisplayName = ptr.String(xtv) 17448 } 17449 17450 case strings.EqualFold("ID", t.Name.Local): 17451 val, err := decoder.Value() 17452 if err != nil { 17453 return err 17454 } 17455 if val == nil { 17456 break 17457 } 17458 { 17459 xtv := string(val) 17460 sv.ID = ptr.String(xtv) 17461 } 17462 17463 default: 17464 // Do nothing and ignore the unexpected tag element 17465 err = decoder.Decoder.Skip() 17466 if err != nil { 17467 return err 17468 } 17469 17470 } 17471 decoder = originalDecoder 17472 } 17473 *v = sv 17474 return nil 17475} 17476 17477func awsRestxml_deserializeDocumentOwnershipControls(v **types.OwnershipControls, decoder smithyxml.NodeDecoder) error { 17478 if v == nil { 17479 return fmt.Errorf("unexpected nil of type %T", v) 17480 } 17481 var sv *types.OwnershipControls 17482 if *v == nil { 17483 sv = &types.OwnershipControls{} 17484 } else { 17485 sv = *v 17486 } 17487 17488 for { 17489 t, done, err := decoder.Token() 17490 if err != nil { 17491 return err 17492 } 17493 if done { 17494 break 17495 } 17496 originalDecoder := decoder 17497 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17498 switch { 17499 case strings.EqualFold("Rule", t.Name.Local): 17500 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17501 if err := awsRestxml_deserializeDocumentOwnershipControlsRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 17502 return err 17503 } 17504 17505 default: 17506 // Do nothing and ignore the unexpected tag element 17507 err = decoder.Decoder.Skip() 17508 if err != nil { 17509 return err 17510 } 17511 17512 } 17513 decoder = originalDecoder 17514 } 17515 *v = sv 17516 return nil 17517} 17518 17519func awsRestxml_deserializeDocumentOwnershipControlsRule(v **types.OwnershipControlsRule, decoder smithyxml.NodeDecoder) error { 17520 if v == nil { 17521 return fmt.Errorf("unexpected nil of type %T", v) 17522 } 17523 var sv *types.OwnershipControlsRule 17524 if *v == nil { 17525 sv = &types.OwnershipControlsRule{} 17526 } else { 17527 sv = *v 17528 } 17529 17530 for { 17531 t, done, err := decoder.Token() 17532 if err != nil { 17533 return err 17534 } 17535 if done { 17536 break 17537 } 17538 originalDecoder := decoder 17539 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17540 switch { 17541 case strings.EqualFold("ObjectOwnership", t.Name.Local): 17542 val, err := decoder.Value() 17543 if err != nil { 17544 return err 17545 } 17546 if val == nil { 17547 break 17548 } 17549 { 17550 xtv := string(val) 17551 sv.ObjectOwnership = types.ObjectOwnership(xtv) 17552 } 17553 17554 default: 17555 // Do nothing and ignore the unexpected tag element 17556 err = decoder.Decoder.Skip() 17557 if err != nil { 17558 return err 17559 } 17560 17561 } 17562 decoder = originalDecoder 17563 } 17564 *v = sv 17565 return nil 17566} 17567 17568func awsRestxml_deserializeDocumentOwnershipControlsRules(v *[]types.OwnershipControlsRule, decoder smithyxml.NodeDecoder) error { 17569 if v == nil { 17570 return fmt.Errorf("unexpected nil of type %T", v) 17571 } 17572 var sv []types.OwnershipControlsRule 17573 if *v == nil { 17574 sv = make([]types.OwnershipControlsRule, 0) 17575 } else { 17576 sv = *v 17577 } 17578 17579 originalDecoder := decoder 17580 for { 17581 t, done, err := decoder.Token() 17582 if err != nil { 17583 return err 17584 } 17585 if done { 17586 break 17587 } 17588 switch { 17589 case strings.EqualFold("member", t.Name.Local): 17590 var col types.OwnershipControlsRule 17591 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17592 destAddr := &col 17593 if err := awsRestxml_deserializeDocumentOwnershipControlsRule(&destAddr, nodeDecoder); err != nil { 17594 return err 17595 } 17596 col = *destAddr 17597 sv = append(sv, col) 17598 17599 default: 17600 err = decoder.Decoder.Skip() 17601 if err != nil { 17602 return err 17603 } 17604 17605 } 17606 decoder = originalDecoder 17607 } 17608 *v = sv 17609 return nil 17610} 17611 17612func awsRestxml_deserializeDocumentOwnershipControlsRulesUnwrapped(v *[]types.OwnershipControlsRule, decoder smithyxml.NodeDecoder) error { 17613 var sv []types.OwnershipControlsRule 17614 if *v == nil { 17615 sv = make([]types.OwnershipControlsRule, 0) 17616 } else { 17617 sv = *v 17618 } 17619 17620 switch { 17621 default: 17622 var mv types.OwnershipControlsRule 17623 t := decoder.StartEl 17624 _ = t 17625 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17626 destAddr := &mv 17627 if err := awsRestxml_deserializeDocumentOwnershipControlsRule(&destAddr, nodeDecoder); err != nil { 17628 return err 17629 } 17630 mv = *destAddr 17631 sv = append(sv, mv) 17632 } 17633 *v = sv 17634 return nil 17635} 17636func awsRestxml_deserializeDocumentPart(v **types.Part, decoder smithyxml.NodeDecoder) error { 17637 if v == nil { 17638 return fmt.Errorf("unexpected nil of type %T", v) 17639 } 17640 var sv *types.Part 17641 if *v == nil { 17642 sv = &types.Part{} 17643 } else { 17644 sv = *v 17645 } 17646 17647 for { 17648 t, done, err := decoder.Token() 17649 if err != nil { 17650 return err 17651 } 17652 if done { 17653 break 17654 } 17655 originalDecoder := decoder 17656 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17657 switch { 17658 case strings.EqualFold("ETag", 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 sv.ETag = ptr.String(xtv) 17669 } 17670 17671 case strings.EqualFold("LastModified", t.Name.Local): 17672 val, err := decoder.Value() 17673 if err != nil { 17674 return err 17675 } 17676 if val == nil { 17677 break 17678 } 17679 { 17680 xtv := string(val) 17681 t, err := smithytime.ParseDateTime(xtv) 17682 if err != nil { 17683 return err 17684 } 17685 sv.LastModified = ptr.Time(t) 17686 } 17687 17688 case strings.EqualFold("PartNumber", t.Name.Local): 17689 val, err := decoder.Value() 17690 if err != nil { 17691 return err 17692 } 17693 if val == nil { 17694 break 17695 } 17696 { 17697 xtv := string(val) 17698 i64, err := strconv.ParseInt(xtv, 10, 64) 17699 if err != nil { 17700 return err 17701 } 17702 sv.PartNumber = int32(i64) 17703 } 17704 17705 case strings.EqualFold("Size", t.Name.Local): 17706 val, err := decoder.Value() 17707 if err != nil { 17708 return err 17709 } 17710 if val == nil { 17711 break 17712 } 17713 { 17714 xtv := string(val) 17715 i64, err := strconv.ParseInt(xtv, 10, 64) 17716 if err != nil { 17717 return err 17718 } 17719 sv.Size = i64 17720 } 17721 17722 default: 17723 // Do nothing and ignore the unexpected tag element 17724 err = decoder.Decoder.Skip() 17725 if err != nil { 17726 return err 17727 } 17728 17729 } 17730 decoder = originalDecoder 17731 } 17732 *v = sv 17733 return nil 17734} 17735 17736func awsRestxml_deserializeDocumentParts(v *[]types.Part, decoder smithyxml.NodeDecoder) error { 17737 if v == nil { 17738 return fmt.Errorf("unexpected nil of type %T", v) 17739 } 17740 var sv []types.Part 17741 if *v == nil { 17742 sv = make([]types.Part, 0) 17743 } else { 17744 sv = *v 17745 } 17746 17747 originalDecoder := decoder 17748 for { 17749 t, done, err := decoder.Token() 17750 if err != nil { 17751 return err 17752 } 17753 if done { 17754 break 17755 } 17756 switch { 17757 case strings.EqualFold("member", t.Name.Local): 17758 var col types.Part 17759 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17760 destAddr := &col 17761 if err := awsRestxml_deserializeDocumentPart(&destAddr, nodeDecoder); err != nil { 17762 return err 17763 } 17764 col = *destAddr 17765 sv = append(sv, col) 17766 17767 default: 17768 err = decoder.Decoder.Skip() 17769 if err != nil { 17770 return err 17771 } 17772 17773 } 17774 decoder = originalDecoder 17775 } 17776 *v = sv 17777 return nil 17778} 17779 17780func awsRestxml_deserializeDocumentPartsUnwrapped(v *[]types.Part, decoder smithyxml.NodeDecoder) error { 17781 var sv []types.Part 17782 if *v == nil { 17783 sv = make([]types.Part, 0) 17784 } else { 17785 sv = *v 17786 } 17787 17788 switch { 17789 default: 17790 var mv types.Part 17791 t := decoder.StartEl 17792 _ = t 17793 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17794 destAddr := &mv 17795 if err := awsRestxml_deserializeDocumentPart(&destAddr, nodeDecoder); err != nil { 17796 return err 17797 } 17798 mv = *destAddr 17799 sv = append(sv, mv) 17800 } 17801 *v = sv 17802 return nil 17803} 17804func awsRestxml_deserializeDocumentPolicyStatus(v **types.PolicyStatus, decoder smithyxml.NodeDecoder) error { 17805 if v == nil { 17806 return fmt.Errorf("unexpected nil of type %T", v) 17807 } 17808 var sv *types.PolicyStatus 17809 if *v == nil { 17810 sv = &types.PolicyStatus{} 17811 } else { 17812 sv = *v 17813 } 17814 17815 for { 17816 t, done, err := decoder.Token() 17817 if err != nil { 17818 return err 17819 } 17820 if done { 17821 break 17822 } 17823 originalDecoder := decoder 17824 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17825 switch { 17826 case strings.EqualFold("IsPublic", t.Name.Local): 17827 val, err := decoder.Value() 17828 if err != nil { 17829 return err 17830 } 17831 if val == nil { 17832 break 17833 } 17834 { 17835 xtv, err := strconv.ParseBool(string(val)) 17836 if err != nil { 17837 return fmt.Errorf("expected IsPublic to be of type *bool, got %T instead", val) 17838 } 17839 sv.IsPublic = xtv 17840 } 17841 17842 default: 17843 // Do nothing and ignore the unexpected tag element 17844 err = decoder.Decoder.Skip() 17845 if err != nil { 17846 return err 17847 } 17848 17849 } 17850 decoder = originalDecoder 17851 } 17852 *v = sv 17853 return nil 17854} 17855 17856func awsRestxml_deserializeDocumentPublicAccessBlockConfiguration(v **types.PublicAccessBlockConfiguration, decoder smithyxml.NodeDecoder) error { 17857 if v == nil { 17858 return fmt.Errorf("unexpected nil of type %T", v) 17859 } 17860 var sv *types.PublicAccessBlockConfiguration 17861 if *v == nil { 17862 sv = &types.PublicAccessBlockConfiguration{} 17863 } else { 17864 sv = *v 17865 } 17866 17867 for { 17868 t, done, err := decoder.Token() 17869 if err != nil { 17870 return err 17871 } 17872 if done { 17873 break 17874 } 17875 originalDecoder := decoder 17876 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17877 switch { 17878 case strings.EqualFold("BlockPublicAcls", t.Name.Local): 17879 val, err := decoder.Value() 17880 if err != nil { 17881 return err 17882 } 17883 if val == nil { 17884 break 17885 } 17886 { 17887 xtv, err := strconv.ParseBool(string(val)) 17888 if err != nil { 17889 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17890 } 17891 sv.BlockPublicAcls = xtv 17892 } 17893 17894 case strings.EqualFold("BlockPublicPolicy", t.Name.Local): 17895 val, err := decoder.Value() 17896 if err != nil { 17897 return err 17898 } 17899 if val == nil { 17900 break 17901 } 17902 { 17903 xtv, err := strconv.ParseBool(string(val)) 17904 if err != nil { 17905 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17906 } 17907 sv.BlockPublicPolicy = xtv 17908 } 17909 17910 case strings.EqualFold("IgnorePublicAcls", t.Name.Local): 17911 val, err := decoder.Value() 17912 if err != nil { 17913 return err 17914 } 17915 if val == nil { 17916 break 17917 } 17918 { 17919 xtv, err := strconv.ParseBool(string(val)) 17920 if err != nil { 17921 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17922 } 17923 sv.IgnorePublicAcls = xtv 17924 } 17925 17926 case strings.EqualFold("RestrictPublicBuckets", t.Name.Local): 17927 val, err := decoder.Value() 17928 if err != nil { 17929 return err 17930 } 17931 if val == nil { 17932 break 17933 } 17934 { 17935 xtv, err := strconv.ParseBool(string(val)) 17936 if err != nil { 17937 return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val) 17938 } 17939 sv.RestrictPublicBuckets = xtv 17940 } 17941 17942 default: 17943 // Do nothing and ignore the unexpected tag element 17944 err = decoder.Decoder.Skip() 17945 if err != nil { 17946 return err 17947 } 17948 17949 } 17950 decoder = originalDecoder 17951 } 17952 *v = sv 17953 return nil 17954} 17955 17956func awsRestxml_deserializeDocumentQueueConfiguration(v **types.QueueConfiguration, decoder smithyxml.NodeDecoder) error { 17957 if v == nil { 17958 return fmt.Errorf("unexpected nil of type %T", v) 17959 } 17960 var sv *types.QueueConfiguration 17961 if *v == nil { 17962 sv = &types.QueueConfiguration{} 17963 } else { 17964 sv = *v 17965 } 17966 17967 for { 17968 t, done, err := decoder.Token() 17969 if err != nil { 17970 return err 17971 } 17972 if done { 17973 break 17974 } 17975 originalDecoder := decoder 17976 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 17977 switch { 17978 case strings.EqualFold("Event", t.Name.Local): 17979 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17980 if err := awsRestxml_deserializeDocumentEventListUnwrapped(&sv.Events, nodeDecoder); err != nil { 17981 return err 17982 } 17983 17984 case strings.EqualFold("Filter", t.Name.Local): 17985 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 17986 if err := awsRestxml_deserializeDocumentNotificationConfigurationFilter(&sv.Filter, nodeDecoder); err != nil { 17987 return err 17988 } 17989 17990 case strings.EqualFold("Id", t.Name.Local): 17991 val, err := decoder.Value() 17992 if err != nil { 17993 return err 17994 } 17995 if val == nil { 17996 break 17997 } 17998 { 17999 xtv := string(val) 18000 sv.Id = ptr.String(xtv) 18001 } 18002 18003 case strings.EqualFold("Queue", t.Name.Local): 18004 val, err := decoder.Value() 18005 if err != nil { 18006 return err 18007 } 18008 if val == nil { 18009 break 18010 } 18011 { 18012 xtv := string(val) 18013 sv.QueueArn = ptr.String(xtv) 18014 } 18015 18016 default: 18017 // Do nothing and ignore the unexpected tag element 18018 err = decoder.Decoder.Skip() 18019 if err != nil { 18020 return err 18021 } 18022 18023 } 18024 decoder = originalDecoder 18025 } 18026 *v = sv 18027 return nil 18028} 18029 18030func awsRestxml_deserializeDocumentQueueConfigurationList(v *[]types.QueueConfiguration, decoder smithyxml.NodeDecoder) error { 18031 if v == nil { 18032 return fmt.Errorf("unexpected nil of type %T", v) 18033 } 18034 var sv []types.QueueConfiguration 18035 if *v == nil { 18036 sv = make([]types.QueueConfiguration, 0) 18037 } else { 18038 sv = *v 18039 } 18040 18041 originalDecoder := decoder 18042 for { 18043 t, done, err := decoder.Token() 18044 if err != nil { 18045 return err 18046 } 18047 if done { 18048 break 18049 } 18050 switch { 18051 case strings.EqualFold("member", t.Name.Local): 18052 var col types.QueueConfiguration 18053 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18054 destAddr := &col 18055 if err := awsRestxml_deserializeDocumentQueueConfiguration(&destAddr, nodeDecoder); err != nil { 18056 return err 18057 } 18058 col = *destAddr 18059 sv = append(sv, col) 18060 18061 default: 18062 err = decoder.Decoder.Skip() 18063 if err != nil { 18064 return err 18065 } 18066 18067 } 18068 decoder = originalDecoder 18069 } 18070 *v = sv 18071 return nil 18072} 18073 18074func awsRestxml_deserializeDocumentQueueConfigurationListUnwrapped(v *[]types.QueueConfiguration, decoder smithyxml.NodeDecoder) error { 18075 var sv []types.QueueConfiguration 18076 if *v == nil { 18077 sv = make([]types.QueueConfiguration, 0) 18078 } else { 18079 sv = *v 18080 } 18081 18082 switch { 18083 default: 18084 var mv types.QueueConfiguration 18085 t := decoder.StartEl 18086 _ = t 18087 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18088 destAddr := &mv 18089 if err := awsRestxml_deserializeDocumentQueueConfiguration(&destAddr, nodeDecoder); err != nil { 18090 return err 18091 } 18092 mv = *destAddr 18093 sv = append(sv, mv) 18094 } 18095 *v = sv 18096 return nil 18097} 18098func awsRestxml_deserializeDocumentRedirect(v **types.Redirect, decoder smithyxml.NodeDecoder) error { 18099 if v == nil { 18100 return fmt.Errorf("unexpected nil of type %T", v) 18101 } 18102 var sv *types.Redirect 18103 if *v == nil { 18104 sv = &types.Redirect{} 18105 } else { 18106 sv = *v 18107 } 18108 18109 for { 18110 t, done, err := decoder.Token() 18111 if err != nil { 18112 return err 18113 } 18114 if done { 18115 break 18116 } 18117 originalDecoder := decoder 18118 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18119 switch { 18120 case strings.EqualFold("HostName", t.Name.Local): 18121 val, err := decoder.Value() 18122 if err != nil { 18123 return err 18124 } 18125 if val == nil { 18126 break 18127 } 18128 { 18129 xtv := string(val) 18130 sv.HostName = ptr.String(xtv) 18131 } 18132 18133 case strings.EqualFold("HttpRedirectCode", t.Name.Local): 18134 val, err := decoder.Value() 18135 if err != nil { 18136 return err 18137 } 18138 if val == nil { 18139 break 18140 } 18141 { 18142 xtv := string(val) 18143 sv.HttpRedirectCode = ptr.String(xtv) 18144 } 18145 18146 case strings.EqualFold("Protocol", t.Name.Local): 18147 val, err := decoder.Value() 18148 if err != nil { 18149 return err 18150 } 18151 if val == nil { 18152 break 18153 } 18154 { 18155 xtv := string(val) 18156 sv.Protocol = types.Protocol(xtv) 18157 } 18158 18159 case strings.EqualFold("ReplaceKeyPrefixWith", t.Name.Local): 18160 val, err := decoder.Value() 18161 if err != nil { 18162 return err 18163 } 18164 if val == nil { 18165 break 18166 } 18167 { 18168 xtv := string(val) 18169 sv.ReplaceKeyPrefixWith = ptr.String(xtv) 18170 } 18171 18172 case strings.EqualFold("ReplaceKeyWith", t.Name.Local): 18173 val, err := decoder.Value() 18174 if err != nil { 18175 return err 18176 } 18177 if val == nil { 18178 break 18179 } 18180 { 18181 xtv := string(val) 18182 sv.ReplaceKeyWith = ptr.String(xtv) 18183 } 18184 18185 default: 18186 // Do nothing and ignore the unexpected tag element 18187 err = decoder.Decoder.Skip() 18188 if err != nil { 18189 return err 18190 } 18191 18192 } 18193 decoder = originalDecoder 18194 } 18195 *v = sv 18196 return nil 18197} 18198 18199func awsRestxml_deserializeDocumentRedirectAllRequestsTo(v **types.RedirectAllRequestsTo, decoder smithyxml.NodeDecoder) error { 18200 if v == nil { 18201 return fmt.Errorf("unexpected nil of type %T", v) 18202 } 18203 var sv *types.RedirectAllRequestsTo 18204 if *v == nil { 18205 sv = &types.RedirectAllRequestsTo{} 18206 } else { 18207 sv = *v 18208 } 18209 18210 for { 18211 t, done, err := decoder.Token() 18212 if err != nil { 18213 return err 18214 } 18215 if done { 18216 break 18217 } 18218 originalDecoder := decoder 18219 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18220 switch { 18221 case strings.EqualFold("HostName", t.Name.Local): 18222 val, err := decoder.Value() 18223 if err != nil { 18224 return err 18225 } 18226 if val == nil { 18227 break 18228 } 18229 { 18230 xtv := string(val) 18231 sv.HostName = ptr.String(xtv) 18232 } 18233 18234 case strings.EqualFold("Protocol", t.Name.Local): 18235 val, err := decoder.Value() 18236 if err != nil { 18237 return err 18238 } 18239 if val == nil { 18240 break 18241 } 18242 { 18243 xtv := string(val) 18244 sv.Protocol = types.Protocol(xtv) 18245 } 18246 18247 default: 18248 // Do nothing and ignore the unexpected tag element 18249 err = decoder.Decoder.Skip() 18250 if err != nil { 18251 return err 18252 } 18253 18254 } 18255 decoder = originalDecoder 18256 } 18257 *v = sv 18258 return nil 18259} 18260 18261func awsRestxml_deserializeDocumentReplicaModifications(v **types.ReplicaModifications, decoder smithyxml.NodeDecoder) error { 18262 if v == nil { 18263 return fmt.Errorf("unexpected nil of type %T", v) 18264 } 18265 var sv *types.ReplicaModifications 18266 if *v == nil { 18267 sv = &types.ReplicaModifications{} 18268 } else { 18269 sv = *v 18270 } 18271 18272 for { 18273 t, done, err := decoder.Token() 18274 if err != nil { 18275 return err 18276 } 18277 if done { 18278 break 18279 } 18280 originalDecoder := decoder 18281 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18282 switch { 18283 case strings.EqualFold("Status", t.Name.Local): 18284 val, err := decoder.Value() 18285 if err != nil { 18286 return err 18287 } 18288 if val == nil { 18289 break 18290 } 18291 { 18292 xtv := string(val) 18293 sv.Status = types.ReplicaModificationsStatus(xtv) 18294 } 18295 18296 default: 18297 // Do nothing and ignore the unexpected tag element 18298 err = decoder.Decoder.Skip() 18299 if err != nil { 18300 return err 18301 } 18302 18303 } 18304 decoder = originalDecoder 18305 } 18306 *v = sv 18307 return nil 18308} 18309 18310func awsRestxml_deserializeDocumentReplicationConfiguration(v **types.ReplicationConfiguration, decoder smithyxml.NodeDecoder) error { 18311 if v == nil { 18312 return fmt.Errorf("unexpected nil of type %T", v) 18313 } 18314 var sv *types.ReplicationConfiguration 18315 if *v == nil { 18316 sv = &types.ReplicationConfiguration{} 18317 } else { 18318 sv = *v 18319 } 18320 18321 for { 18322 t, done, err := decoder.Token() 18323 if err != nil { 18324 return err 18325 } 18326 if done { 18327 break 18328 } 18329 originalDecoder := decoder 18330 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18331 switch { 18332 case strings.EqualFold("Role", t.Name.Local): 18333 val, err := decoder.Value() 18334 if err != nil { 18335 return err 18336 } 18337 if val == nil { 18338 break 18339 } 18340 { 18341 xtv := string(val) 18342 sv.Role = ptr.String(xtv) 18343 } 18344 18345 case strings.EqualFold("Rule", t.Name.Local): 18346 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18347 if err := awsRestxml_deserializeDocumentReplicationRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 18348 return err 18349 } 18350 18351 default: 18352 // Do nothing and ignore the unexpected tag element 18353 err = decoder.Decoder.Skip() 18354 if err != nil { 18355 return err 18356 } 18357 18358 } 18359 decoder = originalDecoder 18360 } 18361 *v = sv 18362 return nil 18363} 18364 18365func awsRestxml_deserializeDocumentReplicationRule(v **types.ReplicationRule, decoder smithyxml.NodeDecoder) error { 18366 if v == nil { 18367 return fmt.Errorf("unexpected nil of type %T", v) 18368 } 18369 var sv *types.ReplicationRule 18370 if *v == nil { 18371 sv = &types.ReplicationRule{} 18372 } else { 18373 sv = *v 18374 } 18375 18376 for { 18377 t, done, err := decoder.Token() 18378 if err != nil { 18379 return err 18380 } 18381 if done { 18382 break 18383 } 18384 originalDecoder := decoder 18385 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18386 switch { 18387 case strings.EqualFold("DeleteMarkerReplication", t.Name.Local): 18388 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18389 if err := awsRestxml_deserializeDocumentDeleteMarkerReplication(&sv.DeleteMarkerReplication, nodeDecoder); err != nil { 18390 return err 18391 } 18392 18393 case strings.EqualFold("Destination", t.Name.Local): 18394 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18395 if err := awsRestxml_deserializeDocumentDestination(&sv.Destination, nodeDecoder); err != nil { 18396 return err 18397 } 18398 18399 case strings.EqualFold("ExistingObjectReplication", t.Name.Local): 18400 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18401 if err := awsRestxml_deserializeDocumentExistingObjectReplication(&sv.ExistingObjectReplication, nodeDecoder); err != nil { 18402 return err 18403 } 18404 18405 case strings.EqualFold("Filter", t.Name.Local): 18406 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18407 if err := awsRestxml_deserializeDocumentReplicationRuleFilter(&sv.Filter, nodeDecoder); err != nil { 18408 return err 18409 } 18410 18411 case strings.EqualFold("ID", t.Name.Local): 18412 val, err := decoder.Value() 18413 if err != nil { 18414 return err 18415 } 18416 if val == nil { 18417 break 18418 } 18419 { 18420 xtv := string(val) 18421 sv.ID = ptr.String(xtv) 18422 } 18423 18424 case strings.EqualFold("Prefix", t.Name.Local): 18425 val, err := decoder.Value() 18426 if err != nil { 18427 return err 18428 } 18429 if val == nil { 18430 break 18431 } 18432 { 18433 xtv := string(val) 18434 sv.Prefix = ptr.String(xtv) 18435 } 18436 18437 case strings.EqualFold("Priority", t.Name.Local): 18438 val, err := decoder.Value() 18439 if err != nil { 18440 return err 18441 } 18442 if val == nil { 18443 break 18444 } 18445 { 18446 xtv := string(val) 18447 i64, err := strconv.ParseInt(xtv, 10, 64) 18448 if err != nil { 18449 return err 18450 } 18451 sv.Priority = int32(i64) 18452 } 18453 18454 case strings.EqualFold("SourceSelectionCriteria", t.Name.Local): 18455 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18456 if err := awsRestxml_deserializeDocumentSourceSelectionCriteria(&sv.SourceSelectionCriteria, nodeDecoder); err != nil { 18457 return err 18458 } 18459 18460 case strings.EqualFold("Status", t.Name.Local): 18461 val, err := decoder.Value() 18462 if err != nil { 18463 return err 18464 } 18465 if val == nil { 18466 break 18467 } 18468 { 18469 xtv := string(val) 18470 sv.Status = types.ReplicationRuleStatus(xtv) 18471 } 18472 18473 default: 18474 // Do nothing and ignore the unexpected tag element 18475 err = decoder.Decoder.Skip() 18476 if err != nil { 18477 return err 18478 } 18479 18480 } 18481 decoder = originalDecoder 18482 } 18483 *v = sv 18484 return nil 18485} 18486 18487func awsRestxml_deserializeDocumentReplicationRuleAndOperator(v **types.ReplicationRuleAndOperator, decoder smithyxml.NodeDecoder) error { 18488 if v == nil { 18489 return fmt.Errorf("unexpected nil of type %T", v) 18490 } 18491 var sv *types.ReplicationRuleAndOperator 18492 if *v == nil { 18493 sv = &types.ReplicationRuleAndOperator{} 18494 } else { 18495 sv = *v 18496 } 18497 18498 for { 18499 t, done, err := decoder.Token() 18500 if err != nil { 18501 return err 18502 } 18503 if done { 18504 break 18505 } 18506 originalDecoder := decoder 18507 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18508 switch { 18509 case strings.EqualFold("Prefix", t.Name.Local): 18510 val, err := decoder.Value() 18511 if err != nil { 18512 return err 18513 } 18514 if val == nil { 18515 break 18516 } 18517 { 18518 xtv := string(val) 18519 sv.Prefix = ptr.String(xtv) 18520 } 18521 18522 case strings.EqualFold("Tag", t.Name.Local): 18523 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18524 if err := awsRestxml_deserializeDocumentTagSetUnwrapped(&sv.Tags, nodeDecoder); err != nil { 18525 return err 18526 } 18527 18528 default: 18529 // Do nothing and ignore the unexpected tag element 18530 err = decoder.Decoder.Skip() 18531 if err != nil { 18532 return err 18533 } 18534 18535 } 18536 decoder = originalDecoder 18537 } 18538 *v = sv 18539 return nil 18540} 18541 18542func awsRestxml_deserializeDocumentReplicationRuleFilter(v *types.ReplicationRuleFilter, decoder smithyxml.NodeDecoder) error { 18543 if v == nil { 18544 return fmt.Errorf("unexpected nil of type %T", v) 18545 } 18546 var uv types.ReplicationRuleFilter 18547 var memberFound bool 18548 for { 18549 t, done, err := decoder.Token() 18550 if err != nil { 18551 return err 18552 } 18553 if done { 18554 break 18555 } 18556 if memberFound { 18557 if err = decoder.Decoder.Skip(); err != nil { 18558 return err 18559 } 18560 } 18561 originalDecoder := decoder 18562 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18563 switch { 18564 case strings.EqualFold("And", t.Name.Local): 18565 var mv types.ReplicationRuleAndOperator 18566 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18567 destAddr := &mv 18568 if err := awsRestxml_deserializeDocumentReplicationRuleAndOperator(&destAddr, nodeDecoder); err != nil { 18569 return err 18570 } 18571 mv = *destAddr 18572 uv = &types.ReplicationRuleFilterMemberAnd{Value: mv} 18573 memberFound = true 18574 18575 case strings.EqualFold("Prefix", t.Name.Local): 18576 var mv string 18577 val, err := decoder.Value() 18578 if err != nil { 18579 return err 18580 } 18581 if val == nil { 18582 break 18583 } 18584 { 18585 xtv := string(val) 18586 mv = xtv 18587 } 18588 uv = &types.ReplicationRuleFilterMemberPrefix{Value: mv} 18589 memberFound = true 18590 18591 case strings.EqualFold("Tag", t.Name.Local): 18592 var mv types.Tag 18593 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18594 destAddr := &mv 18595 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 18596 return err 18597 } 18598 mv = *destAddr 18599 uv = &types.ReplicationRuleFilterMemberTag{Value: mv} 18600 memberFound = true 18601 18602 default: 18603 uv = &types.UnknownUnionMember{Tag: t.Name.Local} 18604 memberFound = true 18605 18606 } 18607 decoder = originalDecoder 18608 } 18609 *v = uv 18610 return nil 18611} 18612 18613func awsRestxml_deserializeDocumentReplicationRules(v *[]types.ReplicationRule, decoder smithyxml.NodeDecoder) error { 18614 if v == nil { 18615 return fmt.Errorf("unexpected nil of type %T", v) 18616 } 18617 var sv []types.ReplicationRule 18618 if *v == nil { 18619 sv = make([]types.ReplicationRule, 0) 18620 } else { 18621 sv = *v 18622 } 18623 18624 originalDecoder := decoder 18625 for { 18626 t, done, err := decoder.Token() 18627 if err != nil { 18628 return err 18629 } 18630 if done { 18631 break 18632 } 18633 switch { 18634 case strings.EqualFold("member", t.Name.Local): 18635 var col types.ReplicationRule 18636 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18637 destAddr := &col 18638 if err := awsRestxml_deserializeDocumentReplicationRule(&destAddr, nodeDecoder); err != nil { 18639 return err 18640 } 18641 col = *destAddr 18642 sv = append(sv, col) 18643 18644 default: 18645 err = decoder.Decoder.Skip() 18646 if err != nil { 18647 return err 18648 } 18649 18650 } 18651 decoder = originalDecoder 18652 } 18653 *v = sv 18654 return nil 18655} 18656 18657func awsRestxml_deserializeDocumentReplicationRulesUnwrapped(v *[]types.ReplicationRule, decoder smithyxml.NodeDecoder) error { 18658 var sv []types.ReplicationRule 18659 if *v == nil { 18660 sv = make([]types.ReplicationRule, 0) 18661 } else { 18662 sv = *v 18663 } 18664 18665 switch { 18666 default: 18667 var mv types.ReplicationRule 18668 t := decoder.StartEl 18669 _ = t 18670 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18671 destAddr := &mv 18672 if err := awsRestxml_deserializeDocumentReplicationRule(&destAddr, nodeDecoder); err != nil { 18673 return err 18674 } 18675 mv = *destAddr 18676 sv = append(sv, mv) 18677 } 18678 *v = sv 18679 return nil 18680} 18681func awsRestxml_deserializeDocumentReplicationTime(v **types.ReplicationTime, decoder smithyxml.NodeDecoder) error { 18682 if v == nil { 18683 return fmt.Errorf("unexpected nil of type %T", v) 18684 } 18685 var sv *types.ReplicationTime 18686 if *v == nil { 18687 sv = &types.ReplicationTime{} 18688 } else { 18689 sv = *v 18690 } 18691 18692 for { 18693 t, done, err := decoder.Token() 18694 if err != nil { 18695 return err 18696 } 18697 if done { 18698 break 18699 } 18700 originalDecoder := decoder 18701 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18702 switch { 18703 case strings.EqualFold("Status", t.Name.Local): 18704 val, err := decoder.Value() 18705 if err != nil { 18706 return err 18707 } 18708 if val == nil { 18709 break 18710 } 18711 { 18712 xtv := string(val) 18713 sv.Status = types.ReplicationTimeStatus(xtv) 18714 } 18715 18716 case strings.EqualFold("Time", t.Name.Local): 18717 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18718 if err := awsRestxml_deserializeDocumentReplicationTimeValue(&sv.Time, nodeDecoder); err != nil { 18719 return err 18720 } 18721 18722 default: 18723 // Do nothing and ignore the unexpected tag element 18724 err = decoder.Decoder.Skip() 18725 if err != nil { 18726 return err 18727 } 18728 18729 } 18730 decoder = originalDecoder 18731 } 18732 *v = sv 18733 return nil 18734} 18735 18736func awsRestxml_deserializeDocumentReplicationTimeValue(v **types.ReplicationTimeValue, decoder smithyxml.NodeDecoder) error { 18737 if v == nil { 18738 return fmt.Errorf("unexpected nil of type %T", v) 18739 } 18740 var sv *types.ReplicationTimeValue 18741 if *v == nil { 18742 sv = &types.ReplicationTimeValue{} 18743 } else { 18744 sv = *v 18745 } 18746 18747 for { 18748 t, done, err := decoder.Token() 18749 if err != nil { 18750 return err 18751 } 18752 if done { 18753 break 18754 } 18755 originalDecoder := decoder 18756 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18757 switch { 18758 case strings.EqualFold("Minutes", t.Name.Local): 18759 val, err := decoder.Value() 18760 if err != nil { 18761 return err 18762 } 18763 if val == nil { 18764 break 18765 } 18766 { 18767 xtv := string(val) 18768 i64, err := strconv.ParseInt(xtv, 10, 64) 18769 if err != nil { 18770 return err 18771 } 18772 sv.Minutes = int32(i64) 18773 } 18774 18775 default: 18776 // Do nothing and ignore the unexpected tag element 18777 err = decoder.Decoder.Skip() 18778 if err != nil { 18779 return err 18780 } 18781 18782 } 18783 decoder = originalDecoder 18784 } 18785 *v = sv 18786 return nil 18787} 18788 18789func awsRestxml_deserializeDocumentRoutingRule(v **types.RoutingRule, decoder smithyxml.NodeDecoder) error { 18790 if v == nil { 18791 return fmt.Errorf("unexpected nil of type %T", v) 18792 } 18793 var sv *types.RoutingRule 18794 if *v == nil { 18795 sv = &types.RoutingRule{} 18796 } else { 18797 sv = *v 18798 } 18799 18800 for { 18801 t, done, err := decoder.Token() 18802 if err != nil { 18803 return err 18804 } 18805 if done { 18806 break 18807 } 18808 originalDecoder := decoder 18809 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18810 switch { 18811 case strings.EqualFold("Condition", t.Name.Local): 18812 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18813 if err := awsRestxml_deserializeDocumentCondition(&sv.Condition, nodeDecoder); err != nil { 18814 return err 18815 } 18816 18817 case strings.EqualFold("Redirect", t.Name.Local): 18818 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18819 if err := awsRestxml_deserializeDocumentRedirect(&sv.Redirect, nodeDecoder); err != nil { 18820 return err 18821 } 18822 18823 default: 18824 // Do nothing and ignore the unexpected tag element 18825 err = decoder.Decoder.Skip() 18826 if err != nil { 18827 return err 18828 } 18829 18830 } 18831 decoder = originalDecoder 18832 } 18833 *v = sv 18834 return nil 18835} 18836 18837func awsRestxml_deserializeDocumentRoutingRules(v *[]types.RoutingRule, decoder smithyxml.NodeDecoder) error { 18838 if v == nil { 18839 return fmt.Errorf("unexpected nil of type %T", v) 18840 } 18841 var sv []types.RoutingRule 18842 if *v == nil { 18843 sv = make([]types.RoutingRule, 0) 18844 } else { 18845 sv = *v 18846 } 18847 18848 originalDecoder := decoder 18849 for { 18850 t, done, err := decoder.Token() 18851 if err != nil { 18852 return err 18853 } 18854 if done { 18855 break 18856 } 18857 switch { 18858 case strings.EqualFold("RoutingRule", t.Name.Local): 18859 var col types.RoutingRule 18860 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18861 destAddr := &col 18862 if err := awsRestxml_deserializeDocumentRoutingRule(&destAddr, nodeDecoder); err != nil { 18863 return err 18864 } 18865 col = *destAddr 18866 sv = append(sv, col) 18867 18868 default: 18869 err = decoder.Decoder.Skip() 18870 if err != nil { 18871 return err 18872 } 18873 18874 } 18875 decoder = originalDecoder 18876 } 18877 *v = sv 18878 return nil 18879} 18880 18881func awsRestxml_deserializeDocumentRoutingRulesUnwrapped(v *[]types.RoutingRule, decoder smithyxml.NodeDecoder) error { 18882 var sv []types.RoutingRule 18883 if *v == nil { 18884 sv = make([]types.RoutingRule, 0) 18885 } else { 18886 sv = *v 18887 } 18888 18889 switch { 18890 default: 18891 var mv types.RoutingRule 18892 t := decoder.StartEl 18893 _ = t 18894 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18895 destAddr := &mv 18896 if err := awsRestxml_deserializeDocumentRoutingRule(&destAddr, nodeDecoder); err != nil { 18897 return err 18898 } 18899 mv = *destAddr 18900 sv = append(sv, mv) 18901 } 18902 *v = sv 18903 return nil 18904} 18905func awsRestxml_deserializeDocumentS3KeyFilter(v **types.S3KeyFilter, decoder smithyxml.NodeDecoder) error { 18906 if v == nil { 18907 return fmt.Errorf("unexpected nil of type %T", v) 18908 } 18909 var sv *types.S3KeyFilter 18910 if *v == nil { 18911 sv = &types.S3KeyFilter{} 18912 } else { 18913 sv = *v 18914 } 18915 18916 for { 18917 t, done, err := decoder.Token() 18918 if err != nil { 18919 return err 18920 } 18921 if done { 18922 break 18923 } 18924 originalDecoder := decoder 18925 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18926 switch { 18927 case strings.EqualFold("FilterRule", t.Name.Local): 18928 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 18929 if err := awsRestxml_deserializeDocumentFilterRuleListUnwrapped(&sv.FilterRules, nodeDecoder); err != nil { 18930 return err 18931 } 18932 18933 default: 18934 // Do nothing and ignore the unexpected tag element 18935 err = decoder.Decoder.Skip() 18936 if err != nil { 18937 return err 18938 } 18939 18940 } 18941 decoder = originalDecoder 18942 } 18943 *v = sv 18944 return nil 18945} 18946 18947func awsRestxml_deserializeDocumentServerSideEncryptionByDefault(v **types.ServerSideEncryptionByDefault, decoder smithyxml.NodeDecoder) error { 18948 if v == nil { 18949 return fmt.Errorf("unexpected nil of type %T", v) 18950 } 18951 var sv *types.ServerSideEncryptionByDefault 18952 if *v == nil { 18953 sv = &types.ServerSideEncryptionByDefault{} 18954 } else { 18955 sv = *v 18956 } 18957 18958 for { 18959 t, done, err := decoder.Token() 18960 if err != nil { 18961 return err 18962 } 18963 if done { 18964 break 18965 } 18966 originalDecoder := decoder 18967 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 18968 switch { 18969 case strings.EqualFold("KMSMasterKeyID", t.Name.Local): 18970 val, err := decoder.Value() 18971 if err != nil { 18972 return err 18973 } 18974 if val == nil { 18975 break 18976 } 18977 { 18978 xtv := string(val) 18979 sv.KMSMasterKeyID = ptr.String(xtv) 18980 } 18981 18982 case strings.EqualFold("SSEAlgorithm", t.Name.Local): 18983 val, err := decoder.Value() 18984 if err != nil { 18985 return err 18986 } 18987 if val == nil { 18988 break 18989 } 18990 { 18991 xtv := string(val) 18992 sv.SSEAlgorithm = types.ServerSideEncryption(xtv) 18993 } 18994 18995 default: 18996 // Do nothing and ignore the unexpected tag element 18997 err = decoder.Decoder.Skip() 18998 if err != nil { 18999 return err 19000 } 19001 19002 } 19003 decoder = originalDecoder 19004 } 19005 *v = sv 19006 return nil 19007} 19008 19009func awsRestxml_deserializeDocumentServerSideEncryptionConfiguration(v **types.ServerSideEncryptionConfiguration, decoder smithyxml.NodeDecoder) error { 19010 if v == nil { 19011 return fmt.Errorf("unexpected nil of type %T", v) 19012 } 19013 var sv *types.ServerSideEncryptionConfiguration 19014 if *v == nil { 19015 sv = &types.ServerSideEncryptionConfiguration{} 19016 } else { 19017 sv = *v 19018 } 19019 19020 for { 19021 t, done, err := decoder.Token() 19022 if err != nil { 19023 return err 19024 } 19025 if done { 19026 break 19027 } 19028 originalDecoder := decoder 19029 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19030 switch { 19031 case strings.EqualFold("Rule", t.Name.Local): 19032 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19033 if err := awsRestxml_deserializeDocumentServerSideEncryptionRulesUnwrapped(&sv.Rules, nodeDecoder); err != nil { 19034 return err 19035 } 19036 19037 default: 19038 // Do nothing and ignore the unexpected tag element 19039 err = decoder.Decoder.Skip() 19040 if err != nil { 19041 return err 19042 } 19043 19044 } 19045 decoder = originalDecoder 19046 } 19047 *v = sv 19048 return nil 19049} 19050 19051func awsRestxml_deserializeDocumentServerSideEncryptionRule(v **types.ServerSideEncryptionRule, decoder smithyxml.NodeDecoder) error { 19052 if v == nil { 19053 return fmt.Errorf("unexpected nil of type %T", v) 19054 } 19055 var sv *types.ServerSideEncryptionRule 19056 if *v == nil { 19057 sv = &types.ServerSideEncryptionRule{} 19058 } else { 19059 sv = *v 19060 } 19061 19062 for { 19063 t, done, err := decoder.Token() 19064 if err != nil { 19065 return err 19066 } 19067 if done { 19068 break 19069 } 19070 originalDecoder := decoder 19071 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19072 switch { 19073 case strings.EqualFold("ApplyServerSideEncryptionByDefault", t.Name.Local): 19074 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19075 if err := awsRestxml_deserializeDocumentServerSideEncryptionByDefault(&sv.ApplyServerSideEncryptionByDefault, nodeDecoder); err != nil { 19076 return err 19077 } 19078 19079 case strings.EqualFold("BucketKeyEnabled", t.Name.Local): 19080 val, err := decoder.Value() 19081 if err != nil { 19082 return err 19083 } 19084 if val == nil { 19085 break 19086 } 19087 { 19088 xtv, err := strconv.ParseBool(string(val)) 19089 if err != nil { 19090 return fmt.Errorf("expected BucketKeyEnabled to be of type *bool, got %T instead", val) 19091 } 19092 sv.BucketKeyEnabled = xtv 19093 } 19094 19095 default: 19096 // Do nothing and ignore the unexpected tag element 19097 err = decoder.Decoder.Skip() 19098 if err != nil { 19099 return err 19100 } 19101 19102 } 19103 decoder = originalDecoder 19104 } 19105 *v = sv 19106 return nil 19107} 19108 19109func awsRestxml_deserializeDocumentServerSideEncryptionRules(v *[]types.ServerSideEncryptionRule, decoder smithyxml.NodeDecoder) error { 19110 if v == nil { 19111 return fmt.Errorf("unexpected nil of type %T", v) 19112 } 19113 var sv []types.ServerSideEncryptionRule 19114 if *v == nil { 19115 sv = make([]types.ServerSideEncryptionRule, 0) 19116 } else { 19117 sv = *v 19118 } 19119 19120 originalDecoder := decoder 19121 for { 19122 t, done, err := decoder.Token() 19123 if err != nil { 19124 return err 19125 } 19126 if done { 19127 break 19128 } 19129 switch { 19130 case strings.EqualFold("member", t.Name.Local): 19131 var col types.ServerSideEncryptionRule 19132 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19133 destAddr := &col 19134 if err := awsRestxml_deserializeDocumentServerSideEncryptionRule(&destAddr, nodeDecoder); err != nil { 19135 return err 19136 } 19137 col = *destAddr 19138 sv = append(sv, col) 19139 19140 default: 19141 err = decoder.Decoder.Skip() 19142 if err != nil { 19143 return err 19144 } 19145 19146 } 19147 decoder = originalDecoder 19148 } 19149 *v = sv 19150 return nil 19151} 19152 19153func awsRestxml_deserializeDocumentServerSideEncryptionRulesUnwrapped(v *[]types.ServerSideEncryptionRule, decoder smithyxml.NodeDecoder) error { 19154 var sv []types.ServerSideEncryptionRule 19155 if *v == nil { 19156 sv = make([]types.ServerSideEncryptionRule, 0) 19157 } else { 19158 sv = *v 19159 } 19160 19161 switch { 19162 default: 19163 var mv types.ServerSideEncryptionRule 19164 t := decoder.StartEl 19165 _ = t 19166 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19167 destAddr := &mv 19168 if err := awsRestxml_deserializeDocumentServerSideEncryptionRule(&destAddr, nodeDecoder); err != nil { 19169 return err 19170 } 19171 mv = *destAddr 19172 sv = append(sv, mv) 19173 } 19174 *v = sv 19175 return nil 19176} 19177func awsRestxml_deserializeDocumentSourceSelectionCriteria(v **types.SourceSelectionCriteria, decoder smithyxml.NodeDecoder) error { 19178 if v == nil { 19179 return fmt.Errorf("unexpected nil of type %T", v) 19180 } 19181 var sv *types.SourceSelectionCriteria 19182 if *v == nil { 19183 sv = &types.SourceSelectionCriteria{} 19184 } else { 19185 sv = *v 19186 } 19187 19188 for { 19189 t, done, err := decoder.Token() 19190 if err != nil { 19191 return err 19192 } 19193 if done { 19194 break 19195 } 19196 originalDecoder := decoder 19197 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19198 switch { 19199 case strings.EqualFold("ReplicaModifications", t.Name.Local): 19200 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19201 if err := awsRestxml_deserializeDocumentReplicaModifications(&sv.ReplicaModifications, nodeDecoder); err != nil { 19202 return err 19203 } 19204 19205 case strings.EqualFold("SseKmsEncryptedObjects", t.Name.Local): 19206 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19207 if err := awsRestxml_deserializeDocumentSseKmsEncryptedObjects(&sv.SseKmsEncryptedObjects, nodeDecoder); err != nil { 19208 return err 19209 } 19210 19211 default: 19212 // Do nothing and ignore the unexpected tag element 19213 err = decoder.Decoder.Skip() 19214 if err != nil { 19215 return err 19216 } 19217 19218 } 19219 decoder = originalDecoder 19220 } 19221 *v = sv 19222 return nil 19223} 19224 19225func awsRestxml_deserializeDocumentSSEKMS(v **types.SSEKMS, decoder smithyxml.NodeDecoder) error { 19226 if v == nil { 19227 return fmt.Errorf("unexpected nil of type %T", v) 19228 } 19229 var sv *types.SSEKMS 19230 if *v == nil { 19231 sv = &types.SSEKMS{} 19232 } else { 19233 sv = *v 19234 } 19235 19236 for { 19237 t, done, err := decoder.Token() 19238 if err != nil { 19239 return err 19240 } 19241 if done { 19242 break 19243 } 19244 originalDecoder := decoder 19245 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19246 switch { 19247 case strings.EqualFold("KeyId", t.Name.Local): 19248 val, err := decoder.Value() 19249 if err != nil { 19250 return err 19251 } 19252 if val == nil { 19253 break 19254 } 19255 { 19256 xtv := string(val) 19257 sv.KeyId = ptr.String(xtv) 19258 } 19259 19260 default: 19261 // Do nothing and ignore the unexpected tag element 19262 err = decoder.Decoder.Skip() 19263 if err != nil { 19264 return err 19265 } 19266 19267 } 19268 decoder = originalDecoder 19269 } 19270 *v = sv 19271 return nil 19272} 19273 19274func awsRestxml_deserializeDocumentSseKmsEncryptedObjects(v **types.SseKmsEncryptedObjects, decoder smithyxml.NodeDecoder) error { 19275 if v == nil { 19276 return fmt.Errorf("unexpected nil of type %T", v) 19277 } 19278 var sv *types.SseKmsEncryptedObjects 19279 if *v == nil { 19280 sv = &types.SseKmsEncryptedObjects{} 19281 } else { 19282 sv = *v 19283 } 19284 19285 for { 19286 t, done, err := decoder.Token() 19287 if err != nil { 19288 return err 19289 } 19290 if done { 19291 break 19292 } 19293 originalDecoder := decoder 19294 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19295 switch { 19296 case strings.EqualFold("Status", t.Name.Local): 19297 val, err := decoder.Value() 19298 if err != nil { 19299 return err 19300 } 19301 if val == nil { 19302 break 19303 } 19304 { 19305 xtv := string(val) 19306 sv.Status = types.SseKmsEncryptedObjectsStatus(xtv) 19307 } 19308 19309 default: 19310 // Do nothing and ignore the unexpected tag element 19311 err = decoder.Decoder.Skip() 19312 if err != nil { 19313 return err 19314 } 19315 19316 } 19317 decoder = originalDecoder 19318 } 19319 *v = sv 19320 return nil 19321} 19322 19323func awsRestxml_deserializeDocumentSSES3(v **types.SSES3, decoder smithyxml.NodeDecoder) error { 19324 if v == nil { 19325 return fmt.Errorf("unexpected nil of type %T", v) 19326 } 19327 var sv *types.SSES3 19328 if *v == nil { 19329 sv = &types.SSES3{} 19330 } else { 19331 sv = *v 19332 } 19333 19334 for { 19335 t, done, err := decoder.Token() 19336 if err != nil { 19337 return err 19338 } 19339 if done { 19340 break 19341 } 19342 originalDecoder := decoder 19343 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19344 switch { 19345 default: 19346 // Do nothing and ignore the unexpected tag element 19347 err = decoder.Decoder.Skip() 19348 if err != nil { 19349 return err 19350 } 19351 19352 } 19353 decoder = originalDecoder 19354 } 19355 *v = sv 19356 return nil 19357} 19358 19359func awsRestxml_deserializeDocumentStorageClassAnalysis(v **types.StorageClassAnalysis, decoder smithyxml.NodeDecoder) error { 19360 if v == nil { 19361 return fmt.Errorf("unexpected nil of type %T", v) 19362 } 19363 var sv *types.StorageClassAnalysis 19364 if *v == nil { 19365 sv = &types.StorageClassAnalysis{} 19366 } else { 19367 sv = *v 19368 } 19369 19370 for { 19371 t, done, err := decoder.Token() 19372 if err != nil { 19373 return err 19374 } 19375 if done { 19376 break 19377 } 19378 originalDecoder := decoder 19379 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19380 switch { 19381 case strings.EqualFold("DataExport", t.Name.Local): 19382 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19383 if err := awsRestxml_deserializeDocumentStorageClassAnalysisDataExport(&sv.DataExport, nodeDecoder); err != nil { 19384 return err 19385 } 19386 19387 default: 19388 // Do nothing and ignore the unexpected tag element 19389 err = decoder.Decoder.Skip() 19390 if err != nil { 19391 return err 19392 } 19393 19394 } 19395 decoder = originalDecoder 19396 } 19397 *v = sv 19398 return nil 19399} 19400 19401func awsRestxml_deserializeDocumentStorageClassAnalysisDataExport(v **types.StorageClassAnalysisDataExport, decoder smithyxml.NodeDecoder) error { 19402 if v == nil { 19403 return fmt.Errorf("unexpected nil of type %T", v) 19404 } 19405 var sv *types.StorageClassAnalysisDataExport 19406 if *v == nil { 19407 sv = &types.StorageClassAnalysisDataExport{} 19408 } else { 19409 sv = *v 19410 } 19411 19412 for { 19413 t, done, err := decoder.Token() 19414 if err != nil { 19415 return err 19416 } 19417 if done { 19418 break 19419 } 19420 originalDecoder := decoder 19421 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19422 switch { 19423 case strings.EqualFold("Destination", t.Name.Local): 19424 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19425 if err := awsRestxml_deserializeDocumentAnalyticsExportDestination(&sv.Destination, nodeDecoder); err != nil { 19426 return err 19427 } 19428 19429 case strings.EqualFold("OutputSchemaVersion", t.Name.Local): 19430 val, err := decoder.Value() 19431 if err != nil { 19432 return err 19433 } 19434 if val == nil { 19435 break 19436 } 19437 { 19438 xtv := string(val) 19439 sv.OutputSchemaVersion = types.StorageClassAnalysisSchemaVersion(xtv) 19440 } 19441 19442 default: 19443 // Do nothing and ignore the unexpected tag element 19444 err = decoder.Decoder.Skip() 19445 if err != nil { 19446 return err 19447 } 19448 19449 } 19450 decoder = originalDecoder 19451 } 19452 *v = sv 19453 return nil 19454} 19455 19456func awsRestxml_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error { 19457 if v == nil { 19458 return fmt.Errorf("unexpected nil of type %T", v) 19459 } 19460 var sv *types.Tag 19461 if *v == nil { 19462 sv = &types.Tag{} 19463 } else { 19464 sv = *v 19465 } 19466 19467 for { 19468 t, done, err := decoder.Token() 19469 if err != nil { 19470 return err 19471 } 19472 if done { 19473 break 19474 } 19475 originalDecoder := decoder 19476 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19477 switch { 19478 case strings.EqualFold("Key", t.Name.Local): 19479 val, err := decoder.Value() 19480 if err != nil { 19481 return err 19482 } 19483 if val == nil { 19484 break 19485 } 19486 { 19487 xtv := string(val) 19488 sv.Key = ptr.String(xtv) 19489 } 19490 19491 case strings.EqualFold("Value", t.Name.Local): 19492 val, err := decoder.Value() 19493 if err != nil { 19494 return err 19495 } 19496 if val == nil { 19497 break 19498 } 19499 { 19500 xtv := string(val) 19501 sv.Value = ptr.String(xtv) 19502 } 19503 19504 default: 19505 // Do nothing and ignore the unexpected tag element 19506 err = decoder.Decoder.Skip() 19507 if err != nil { 19508 return err 19509 } 19510 19511 } 19512 decoder = originalDecoder 19513 } 19514 *v = sv 19515 return nil 19516} 19517 19518func awsRestxml_deserializeDocumentTagSet(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 19519 if v == nil { 19520 return fmt.Errorf("unexpected nil of type %T", v) 19521 } 19522 var sv []types.Tag 19523 if *v == nil { 19524 sv = make([]types.Tag, 0) 19525 } else { 19526 sv = *v 19527 } 19528 19529 originalDecoder := decoder 19530 for { 19531 t, done, err := decoder.Token() 19532 if err != nil { 19533 return err 19534 } 19535 if done { 19536 break 19537 } 19538 switch { 19539 case strings.EqualFold("Tag", t.Name.Local): 19540 var col types.Tag 19541 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19542 destAddr := &col 19543 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 19544 return err 19545 } 19546 col = *destAddr 19547 sv = append(sv, col) 19548 19549 default: 19550 err = decoder.Decoder.Skip() 19551 if err != nil { 19552 return err 19553 } 19554 19555 } 19556 decoder = originalDecoder 19557 } 19558 *v = sv 19559 return nil 19560} 19561 19562func awsRestxml_deserializeDocumentTagSetUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error { 19563 var sv []types.Tag 19564 if *v == nil { 19565 sv = make([]types.Tag, 0) 19566 } else { 19567 sv = *v 19568 } 19569 19570 switch { 19571 default: 19572 var mv types.Tag 19573 t := decoder.StartEl 19574 _ = t 19575 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19576 destAddr := &mv 19577 if err := awsRestxml_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil { 19578 return err 19579 } 19580 mv = *destAddr 19581 sv = append(sv, mv) 19582 } 19583 *v = sv 19584 return nil 19585} 19586func awsRestxml_deserializeDocumentTargetGrant(v **types.TargetGrant, decoder smithyxml.NodeDecoder) error { 19587 if v == nil { 19588 return fmt.Errorf("unexpected nil of type %T", v) 19589 } 19590 var sv *types.TargetGrant 19591 if *v == nil { 19592 sv = &types.TargetGrant{} 19593 } else { 19594 sv = *v 19595 } 19596 19597 for { 19598 t, done, err := decoder.Token() 19599 if err != nil { 19600 return err 19601 } 19602 if done { 19603 break 19604 } 19605 originalDecoder := decoder 19606 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19607 switch { 19608 case strings.EqualFold("Grantee", t.Name.Local): 19609 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19610 if err := awsRestxml_deserializeDocumentGrantee(&sv.Grantee, nodeDecoder); err != nil { 19611 return err 19612 } 19613 19614 case strings.EqualFold("Permission", t.Name.Local): 19615 val, err := decoder.Value() 19616 if err != nil { 19617 return err 19618 } 19619 if val == nil { 19620 break 19621 } 19622 { 19623 xtv := string(val) 19624 sv.Permission = types.BucketLogsPermission(xtv) 19625 } 19626 19627 default: 19628 // Do nothing and ignore the unexpected tag element 19629 err = decoder.Decoder.Skip() 19630 if err != nil { 19631 return err 19632 } 19633 19634 } 19635 decoder = originalDecoder 19636 } 19637 *v = sv 19638 return nil 19639} 19640 19641func awsRestxml_deserializeDocumentTargetGrants(v *[]types.TargetGrant, decoder smithyxml.NodeDecoder) error { 19642 if v == nil { 19643 return fmt.Errorf("unexpected nil of type %T", v) 19644 } 19645 var sv []types.TargetGrant 19646 if *v == nil { 19647 sv = make([]types.TargetGrant, 0) 19648 } else { 19649 sv = *v 19650 } 19651 19652 originalDecoder := decoder 19653 for { 19654 t, done, err := decoder.Token() 19655 if err != nil { 19656 return err 19657 } 19658 if done { 19659 break 19660 } 19661 switch { 19662 case strings.EqualFold("Grant", t.Name.Local): 19663 var col types.TargetGrant 19664 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19665 destAddr := &col 19666 if err := awsRestxml_deserializeDocumentTargetGrant(&destAddr, nodeDecoder); err != nil { 19667 return err 19668 } 19669 col = *destAddr 19670 sv = append(sv, col) 19671 19672 default: 19673 err = decoder.Decoder.Skip() 19674 if err != nil { 19675 return err 19676 } 19677 19678 } 19679 decoder = originalDecoder 19680 } 19681 *v = sv 19682 return nil 19683} 19684 19685func awsRestxml_deserializeDocumentTargetGrantsUnwrapped(v *[]types.TargetGrant, decoder smithyxml.NodeDecoder) error { 19686 var sv []types.TargetGrant 19687 if *v == nil { 19688 sv = make([]types.TargetGrant, 0) 19689 } else { 19690 sv = *v 19691 } 19692 19693 switch { 19694 default: 19695 var mv types.TargetGrant 19696 t := decoder.StartEl 19697 _ = t 19698 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19699 destAddr := &mv 19700 if err := awsRestxml_deserializeDocumentTargetGrant(&destAddr, nodeDecoder); err != nil { 19701 return err 19702 } 19703 mv = *destAddr 19704 sv = append(sv, mv) 19705 } 19706 *v = sv 19707 return nil 19708} 19709func awsRestxml_deserializeDocumentTiering(v **types.Tiering, decoder smithyxml.NodeDecoder) error { 19710 if v == nil { 19711 return fmt.Errorf("unexpected nil of type %T", v) 19712 } 19713 var sv *types.Tiering 19714 if *v == nil { 19715 sv = &types.Tiering{} 19716 } else { 19717 sv = *v 19718 } 19719 19720 for { 19721 t, done, err := decoder.Token() 19722 if err != nil { 19723 return err 19724 } 19725 if done { 19726 break 19727 } 19728 originalDecoder := decoder 19729 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19730 switch { 19731 case strings.EqualFold("AccessTier", t.Name.Local): 19732 val, err := decoder.Value() 19733 if err != nil { 19734 return err 19735 } 19736 if val == nil { 19737 break 19738 } 19739 { 19740 xtv := string(val) 19741 sv.AccessTier = types.IntelligentTieringAccessTier(xtv) 19742 } 19743 19744 case strings.EqualFold("Days", t.Name.Local): 19745 val, err := decoder.Value() 19746 if err != nil { 19747 return err 19748 } 19749 if val == nil { 19750 break 19751 } 19752 { 19753 xtv := string(val) 19754 i64, err := strconv.ParseInt(xtv, 10, 64) 19755 if err != nil { 19756 return err 19757 } 19758 sv.Days = int32(i64) 19759 } 19760 19761 default: 19762 // Do nothing and ignore the unexpected tag element 19763 err = decoder.Decoder.Skip() 19764 if err != nil { 19765 return err 19766 } 19767 19768 } 19769 decoder = originalDecoder 19770 } 19771 *v = sv 19772 return nil 19773} 19774 19775func awsRestxml_deserializeDocumentTieringList(v *[]types.Tiering, decoder smithyxml.NodeDecoder) error { 19776 if v == nil { 19777 return fmt.Errorf("unexpected nil of type %T", v) 19778 } 19779 var sv []types.Tiering 19780 if *v == nil { 19781 sv = make([]types.Tiering, 0) 19782 } else { 19783 sv = *v 19784 } 19785 19786 originalDecoder := decoder 19787 for { 19788 t, done, err := decoder.Token() 19789 if err != nil { 19790 return err 19791 } 19792 if done { 19793 break 19794 } 19795 switch { 19796 case strings.EqualFold("member", t.Name.Local): 19797 var col types.Tiering 19798 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19799 destAddr := &col 19800 if err := awsRestxml_deserializeDocumentTiering(&destAddr, nodeDecoder); err != nil { 19801 return err 19802 } 19803 col = *destAddr 19804 sv = append(sv, col) 19805 19806 default: 19807 err = decoder.Decoder.Skip() 19808 if err != nil { 19809 return err 19810 } 19811 19812 } 19813 decoder = originalDecoder 19814 } 19815 *v = sv 19816 return nil 19817} 19818 19819func awsRestxml_deserializeDocumentTieringListUnwrapped(v *[]types.Tiering, decoder smithyxml.NodeDecoder) error { 19820 var sv []types.Tiering 19821 if *v == nil { 19822 sv = make([]types.Tiering, 0) 19823 } else { 19824 sv = *v 19825 } 19826 19827 switch { 19828 default: 19829 var mv types.Tiering 19830 t := decoder.StartEl 19831 _ = t 19832 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19833 destAddr := &mv 19834 if err := awsRestxml_deserializeDocumentTiering(&destAddr, nodeDecoder); err != nil { 19835 return err 19836 } 19837 mv = *destAddr 19838 sv = append(sv, mv) 19839 } 19840 *v = sv 19841 return nil 19842} 19843func awsRestxml_deserializeDocumentTopicConfiguration(v **types.TopicConfiguration, decoder smithyxml.NodeDecoder) error { 19844 if v == nil { 19845 return fmt.Errorf("unexpected nil of type %T", v) 19846 } 19847 var sv *types.TopicConfiguration 19848 if *v == nil { 19849 sv = &types.TopicConfiguration{} 19850 } else { 19851 sv = *v 19852 } 19853 19854 for { 19855 t, done, err := decoder.Token() 19856 if err != nil { 19857 return err 19858 } 19859 if done { 19860 break 19861 } 19862 originalDecoder := decoder 19863 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 19864 switch { 19865 case strings.EqualFold("Event", t.Name.Local): 19866 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19867 if err := awsRestxml_deserializeDocumentEventListUnwrapped(&sv.Events, nodeDecoder); err != nil { 19868 return err 19869 } 19870 19871 case strings.EqualFold("Filter", t.Name.Local): 19872 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19873 if err := awsRestxml_deserializeDocumentNotificationConfigurationFilter(&sv.Filter, nodeDecoder); err != nil { 19874 return err 19875 } 19876 19877 case strings.EqualFold("Id", t.Name.Local): 19878 val, err := decoder.Value() 19879 if err != nil { 19880 return err 19881 } 19882 if val == nil { 19883 break 19884 } 19885 { 19886 xtv := string(val) 19887 sv.Id = ptr.String(xtv) 19888 } 19889 19890 case strings.EqualFold("Topic", t.Name.Local): 19891 val, err := decoder.Value() 19892 if err != nil { 19893 return err 19894 } 19895 if val == nil { 19896 break 19897 } 19898 { 19899 xtv := string(val) 19900 sv.TopicArn = ptr.String(xtv) 19901 } 19902 19903 default: 19904 // Do nothing and ignore the unexpected tag element 19905 err = decoder.Decoder.Skip() 19906 if err != nil { 19907 return err 19908 } 19909 19910 } 19911 decoder = originalDecoder 19912 } 19913 *v = sv 19914 return nil 19915} 19916 19917func awsRestxml_deserializeDocumentTopicConfigurationList(v *[]types.TopicConfiguration, decoder smithyxml.NodeDecoder) error { 19918 if v == nil { 19919 return fmt.Errorf("unexpected nil of type %T", v) 19920 } 19921 var sv []types.TopicConfiguration 19922 if *v == nil { 19923 sv = make([]types.TopicConfiguration, 0) 19924 } else { 19925 sv = *v 19926 } 19927 19928 originalDecoder := decoder 19929 for { 19930 t, done, err := decoder.Token() 19931 if err != nil { 19932 return err 19933 } 19934 if done { 19935 break 19936 } 19937 switch { 19938 case strings.EqualFold("member", t.Name.Local): 19939 var col types.TopicConfiguration 19940 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19941 destAddr := &col 19942 if err := awsRestxml_deserializeDocumentTopicConfiguration(&destAddr, nodeDecoder); err != nil { 19943 return err 19944 } 19945 col = *destAddr 19946 sv = append(sv, col) 19947 19948 default: 19949 err = decoder.Decoder.Skip() 19950 if err != nil { 19951 return err 19952 } 19953 19954 } 19955 decoder = originalDecoder 19956 } 19957 *v = sv 19958 return nil 19959} 19960 19961func awsRestxml_deserializeDocumentTopicConfigurationListUnwrapped(v *[]types.TopicConfiguration, decoder smithyxml.NodeDecoder) error { 19962 var sv []types.TopicConfiguration 19963 if *v == nil { 19964 sv = make([]types.TopicConfiguration, 0) 19965 } else { 19966 sv = *v 19967 } 19968 19969 switch { 19970 default: 19971 var mv types.TopicConfiguration 19972 t := decoder.StartEl 19973 _ = t 19974 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 19975 destAddr := &mv 19976 if err := awsRestxml_deserializeDocumentTopicConfiguration(&destAddr, nodeDecoder); err != nil { 19977 return err 19978 } 19979 mv = *destAddr 19980 sv = append(sv, mv) 19981 } 19982 *v = sv 19983 return nil 19984} 19985func awsRestxml_deserializeDocumentTransition(v **types.Transition, decoder smithyxml.NodeDecoder) error { 19986 if v == nil { 19987 return fmt.Errorf("unexpected nil of type %T", v) 19988 } 19989 var sv *types.Transition 19990 if *v == nil { 19991 sv = &types.Transition{} 19992 } else { 19993 sv = *v 19994 } 19995 19996 for { 19997 t, done, err := decoder.Token() 19998 if err != nil { 19999 return err 20000 } 20001 if done { 20002 break 20003 } 20004 originalDecoder := decoder 20005 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 20006 switch { 20007 case strings.EqualFold("Date", t.Name.Local): 20008 val, err := decoder.Value() 20009 if err != nil { 20010 return err 20011 } 20012 if val == nil { 20013 break 20014 } 20015 { 20016 xtv := string(val) 20017 t, err := smithytime.ParseDateTime(xtv) 20018 if err != nil { 20019 return err 20020 } 20021 sv.Date = ptr.Time(t) 20022 } 20023 20024 case strings.EqualFold("Days", t.Name.Local): 20025 val, err := decoder.Value() 20026 if err != nil { 20027 return err 20028 } 20029 if val == nil { 20030 break 20031 } 20032 { 20033 xtv := string(val) 20034 i64, err := strconv.ParseInt(xtv, 10, 64) 20035 if err != nil { 20036 return err 20037 } 20038 sv.Days = int32(i64) 20039 } 20040 20041 case strings.EqualFold("StorageClass", t.Name.Local): 20042 val, err := decoder.Value() 20043 if err != nil { 20044 return err 20045 } 20046 if val == nil { 20047 break 20048 } 20049 { 20050 xtv := string(val) 20051 sv.StorageClass = types.TransitionStorageClass(xtv) 20052 } 20053 20054 default: 20055 // Do nothing and ignore the unexpected tag element 20056 err = decoder.Decoder.Skip() 20057 if err != nil { 20058 return err 20059 } 20060 20061 } 20062 decoder = originalDecoder 20063 } 20064 *v = sv 20065 return nil 20066} 20067 20068func awsRestxml_deserializeDocumentTransitionList(v *[]types.Transition, decoder smithyxml.NodeDecoder) error { 20069 if v == nil { 20070 return fmt.Errorf("unexpected nil of type %T", v) 20071 } 20072 var sv []types.Transition 20073 if *v == nil { 20074 sv = make([]types.Transition, 0) 20075 } else { 20076 sv = *v 20077 } 20078 20079 originalDecoder := decoder 20080 for { 20081 t, done, err := decoder.Token() 20082 if err != nil { 20083 return err 20084 } 20085 if done { 20086 break 20087 } 20088 switch { 20089 case strings.EqualFold("member", t.Name.Local): 20090 var col types.Transition 20091 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20092 destAddr := &col 20093 if err := awsRestxml_deserializeDocumentTransition(&destAddr, nodeDecoder); err != nil { 20094 return err 20095 } 20096 col = *destAddr 20097 sv = append(sv, col) 20098 20099 default: 20100 err = decoder.Decoder.Skip() 20101 if err != nil { 20102 return err 20103 } 20104 20105 } 20106 decoder = originalDecoder 20107 } 20108 *v = sv 20109 return nil 20110} 20111 20112func awsRestxml_deserializeDocumentTransitionListUnwrapped(v *[]types.Transition, decoder smithyxml.NodeDecoder) error { 20113 var sv []types.Transition 20114 if *v == nil { 20115 sv = make([]types.Transition, 0) 20116 } else { 20117 sv = *v 20118 } 20119 20120 switch { 20121 default: 20122 var mv types.Transition 20123 t := decoder.StartEl 20124 _ = t 20125 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 20126 destAddr := &mv 20127 if err := awsRestxml_deserializeDocumentTransition(&destAddr, nodeDecoder); err != nil { 20128 return err 20129 } 20130 mv = *destAddr 20131 sv = append(sv, mv) 20132 } 20133 *v = sv 20134 return nil 20135} 20136