1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package elasticinference 4 5import ( 6 "bytes" 7 "context" 8 "encoding/json" 9 "fmt" 10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 11 "github.com/aws/aws-sdk-go-v2/service/elasticinference/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithyhttp "github.com/aws/smithy-go/transport/http" 17 "io" 18 "strings" 19) 20 21type awsRestjson1_deserializeOpDescribeAcceleratorOfferings struct { 22} 23 24func (*awsRestjson1_deserializeOpDescribeAcceleratorOfferings) ID() string { 25 return "OperationDeserializer" 26} 27 28func (m *awsRestjson1_deserializeOpDescribeAcceleratorOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 29 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 30) { 31 out, metadata, err = next.HandleDeserialize(ctx, in) 32 if err != nil { 33 return out, metadata, err 34 } 35 36 response, ok := out.RawResponse.(*smithyhttp.Response) 37 if !ok { 38 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 39 } 40 41 if response.StatusCode < 200 || response.StatusCode >= 300 { 42 return out, metadata, awsRestjson1_deserializeOpErrorDescribeAcceleratorOfferings(response, &metadata) 43 } 44 output := &DescribeAcceleratorOfferingsOutput{} 45 out.Result = output 46 47 var buff [1024]byte 48 ringBuffer := smithyio.NewRingBuffer(buff[:]) 49 50 body := io.TeeReader(response.Body, ringBuffer) 51 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsRestjson1_deserializeOpDocumentDescribeAcceleratorOfferingsOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 return out, metadata, &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 } 74 75 return out, metadata, err 76} 77 78func awsRestjson1_deserializeOpErrorDescribeAcceleratorOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 79 var errorBuffer bytes.Buffer 80 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 81 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 82 } 83 errorBody := bytes.NewReader(errorBuffer.Bytes()) 84 85 errorCode := "UnknownError" 86 errorMessage := errorCode 87 88 code := response.Header.Get("X-Amzn-ErrorType") 89 if len(code) != 0 { 90 errorCode = restjson.SanitizeErrorCode(code) 91 } 92 93 var buff [1024]byte 94 ringBuffer := smithyio.NewRingBuffer(buff[:]) 95 96 body := io.TeeReader(errorBody, ringBuffer) 97 decoder := json.NewDecoder(body) 98 decoder.UseNumber() 99 code, message, err := restjson.GetErrorInfo(decoder) 100 if err != nil { 101 var snapshot bytes.Buffer 102 io.Copy(&snapshot, ringBuffer) 103 err = &smithy.DeserializationError{ 104 Err: fmt.Errorf("failed to decode response body, %w", err), 105 Snapshot: snapshot.Bytes(), 106 } 107 return err 108 } 109 110 errorBody.Seek(0, io.SeekStart) 111 if len(code) != 0 { 112 errorCode = restjson.SanitizeErrorCode(code) 113 } 114 if len(message) != 0 { 115 errorMessage = message 116 } 117 118 switch { 119 case strings.EqualFold("BadRequestException", errorCode): 120 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 121 122 case strings.EqualFold("InternalServerException", errorCode): 123 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 124 125 case strings.EqualFold("ResourceNotFoundException", errorCode): 126 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 127 128 default: 129 genericError := &smithy.GenericAPIError{ 130 Code: errorCode, 131 Message: errorMessage, 132 } 133 return genericError 134 135 } 136} 137 138func awsRestjson1_deserializeOpDocumentDescribeAcceleratorOfferingsOutput(v **DescribeAcceleratorOfferingsOutput, value interface{}) error { 139 if v == nil { 140 return fmt.Errorf("unexpected nil of type %T", v) 141 } 142 if value == nil { 143 return nil 144 } 145 146 shape, ok := value.(map[string]interface{}) 147 if !ok { 148 return fmt.Errorf("unexpected JSON type %v", value) 149 } 150 151 var sv *DescribeAcceleratorOfferingsOutput 152 if *v == nil { 153 sv = &DescribeAcceleratorOfferingsOutput{} 154 } else { 155 sv = *v 156 } 157 158 for key, value := range shape { 159 switch key { 160 case "acceleratorTypeOfferings": 161 if err := awsRestjson1_deserializeDocumentAcceleratorTypeOfferingList(&sv.AcceleratorTypeOfferings, value); err != nil { 162 return err 163 } 164 165 default: 166 _, _ = key, value 167 168 } 169 } 170 *v = sv 171 return nil 172} 173 174type awsRestjson1_deserializeOpDescribeAccelerators struct { 175} 176 177func (*awsRestjson1_deserializeOpDescribeAccelerators) ID() string { 178 return "OperationDeserializer" 179} 180 181func (m *awsRestjson1_deserializeOpDescribeAccelerators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 182 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 183) { 184 out, metadata, err = next.HandleDeserialize(ctx, in) 185 if err != nil { 186 return out, metadata, err 187 } 188 189 response, ok := out.RawResponse.(*smithyhttp.Response) 190 if !ok { 191 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 192 } 193 194 if response.StatusCode < 200 || response.StatusCode >= 300 { 195 return out, metadata, awsRestjson1_deserializeOpErrorDescribeAccelerators(response, &metadata) 196 } 197 output := &DescribeAcceleratorsOutput{} 198 out.Result = output 199 200 var buff [1024]byte 201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 202 203 body := io.TeeReader(response.Body, ringBuffer) 204 205 decoder := json.NewDecoder(body) 206 decoder.UseNumber() 207 var shape interface{} 208 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 209 var snapshot bytes.Buffer 210 io.Copy(&snapshot, ringBuffer) 211 err = &smithy.DeserializationError{ 212 Err: fmt.Errorf("failed to decode response body, %w", err), 213 Snapshot: snapshot.Bytes(), 214 } 215 return out, metadata, err 216 } 217 218 err = awsRestjson1_deserializeOpDocumentDescribeAcceleratorsOutput(&output, shape) 219 if err != nil { 220 var snapshot bytes.Buffer 221 io.Copy(&snapshot, ringBuffer) 222 return out, metadata, &smithy.DeserializationError{ 223 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 224 Snapshot: snapshot.Bytes(), 225 } 226 } 227 228 return out, metadata, err 229} 230 231func awsRestjson1_deserializeOpErrorDescribeAccelerators(response *smithyhttp.Response, metadata *middleware.Metadata) error { 232 var errorBuffer bytes.Buffer 233 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 234 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 235 } 236 errorBody := bytes.NewReader(errorBuffer.Bytes()) 237 238 errorCode := "UnknownError" 239 errorMessage := errorCode 240 241 code := response.Header.Get("X-Amzn-ErrorType") 242 if len(code) != 0 { 243 errorCode = restjson.SanitizeErrorCode(code) 244 } 245 246 var buff [1024]byte 247 ringBuffer := smithyio.NewRingBuffer(buff[:]) 248 249 body := io.TeeReader(errorBody, ringBuffer) 250 decoder := json.NewDecoder(body) 251 decoder.UseNumber() 252 code, message, err := restjson.GetErrorInfo(decoder) 253 if err != nil { 254 var snapshot bytes.Buffer 255 io.Copy(&snapshot, ringBuffer) 256 err = &smithy.DeserializationError{ 257 Err: fmt.Errorf("failed to decode response body, %w", err), 258 Snapshot: snapshot.Bytes(), 259 } 260 return err 261 } 262 263 errorBody.Seek(0, io.SeekStart) 264 if len(code) != 0 { 265 errorCode = restjson.SanitizeErrorCode(code) 266 } 267 if len(message) != 0 { 268 errorMessage = message 269 } 270 271 switch { 272 case strings.EqualFold("BadRequestException", errorCode): 273 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 274 275 case strings.EqualFold("InternalServerException", errorCode): 276 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 277 278 case strings.EqualFold("ResourceNotFoundException", errorCode): 279 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 280 281 default: 282 genericError := &smithy.GenericAPIError{ 283 Code: errorCode, 284 Message: errorMessage, 285 } 286 return genericError 287 288 } 289} 290 291func awsRestjson1_deserializeOpDocumentDescribeAcceleratorsOutput(v **DescribeAcceleratorsOutput, value interface{}) error { 292 if v == nil { 293 return fmt.Errorf("unexpected nil of type %T", v) 294 } 295 if value == nil { 296 return nil 297 } 298 299 shape, ok := value.(map[string]interface{}) 300 if !ok { 301 return fmt.Errorf("unexpected JSON type %v", value) 302 } 303 304 var sv *DescribeAcceleratorsOutput 305 if *v == nil { 306 sv = &DescribeAcceleratorsOutput{} 307 } else { 308 sv = *v 309 } 310 311 for key, value := range shape { 312 switch key { 313 case "acceleratorSet": 314 if err := awsRestjson1_deserializeDocumentElasticInferenceAcceleratorSet(&sv.AcceleratorSet, value); err != nil { 315 return err 316 } 317 318 case "nextToken": 319 if value != nil { 320 jtv, ok := value.(string) 321 if !ok { 322 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 323 } 324 sv.NextToken = ptr.String(jtv) 325 } 326 327 default: 328 _, _ = key, value 329 330 } 331 } 332 *v = sv 333 return nil 334} 335 336type awsRestjson1_deserializeOpDescribeAcceleratorTypes struct { 337} 338 339func (*awsRestjson1_deserializeOpDescribeAcceleratorTypes) ID() string { 340 return "OperationDeserializer" 341} 342 343func (m *awsRestjson1_deserializeOpDescribeAcceleratorTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 344 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 345) { 346 out, metadata, err = next.HandleDeserialize(ctx, in) 347 if err != nil { 348 return out, metadata, err 349 } 350 351 response, ok := out.RawResponse.(*smithyhttp.Response) 352 if !ok { 353 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 354 } 355 356 if response.StatusCode < 200 || response.StatusCode >= 300 { 357 return out, metadata, awsRestjson1_deserializeOpErrorDescribeAcceleratorTypes(response, &metadata) 358 } 359 output := &DescribeAcceleratorTypesOutput{} 360 out.Result = output 361 362 var buff [1024]byte 363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 364 365 body := io.TeeReader(response.Body, ringBuffer) 366 367 decoder := json.NewDecoder(body) 368 decoder.UseNumber() 369 var shape interface{} 370 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 371 var snapshot bytes.Buffer 372 io.Copy(&snapshot, ringBuffer) 373 err = &smithy.DeserializationError{ 374 Err: fmt.Errorf("failed to decode response body, %w", err), 375 Snapshot: snapshot.Bytes(), 376 } 377 return out, metadata, err 378 } 379 380 err = awsRestjson1_deserializeOpDocumentDescribeAcceleratorTypesOutput(&output, shape) 381 if err != nil { 382 var snapshot bytes.Buffer 383 io.Copy(&snapshot, ringBuffer) 384 return out, metadata, &smithy.DeserializationError{ 385 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 386 Snapshot: snapshot.Bytes(), 387 } 388 } 389 390 return out, metadata, err 391} 392 393func awsRestjson1_deserializeOpErrorDescribeAcceleratorTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 394 var errorBuffer bytes.Buffer 395 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 396 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 397 } 398 errorBody := bytes.NewReader(errorBuffer.Bytes()) 399 400 errorCode := "UnknownError" 401 errorMessage := errorCode 402 403 code := response.Header.Get("X-Amzn-ErrorType") 404 if len(code) != 0 { 405 errorCode = restjson.SanitizeErrorCode(code) 406 } 407 408 var buff [1024]byte 409 ringBuffer := smithyio.NewRingBuffer(buff[:]) 410 411 body := io.TeeReader(errorBody, ringBuffer) 412 decoder := json.NewDecoder(body) 413 decoder.UseNumber() 414 code, message, err := restjson.GetErrorInfo(decoder) 415 if err != nil { 416 var snapshot bytes.Buffer 417 io.Copy(&snapshot, ringBuffer) 418 err = &smithy.DeserializationError{ 419 Err: fmt.Errorf("failed to decode response body, %w", err), 420 Snapshot: snapshot.Bytes(), 421 } 422 return err 423 } 424 425 errorBody.Seek(0, io.SeekStart) 426 if len(code) != 0 { 427 errorCode = restjson.SanitizeErrorCode(code) 428 } 429 if len(message) != 0 { 430 errorMessage = message 431 } 432 433 switch { 434 case strings.EqualFold("InternalServerException", errorCode): 435 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 436 437 default: 438 genericError := &smithy.GenericAPIError{ 439 Code: errorCode, 440 Message: errorMessage, 441 } 442 return genericError 443 444 } 445} 446 447func awsRestjson1_deserializeOpDocumentDescribeAcceleratorTypesOutput(v **DescribeAcceleratorTypesOutput, value interface{}) error { 448 if v == nil { 449 return fmt.Errorf("unexpected nil of type %T", v) 450 } 451 if value == nil { 452 return nil 453 } 454 455 shape, ok := value.(map[string]interface{}) 456 if !ok { 457 return fmt.Errorf("unexpected JSON type %v", value) 458 } 459 460 var sv *DescribeAcceleratorTypesOutput 461 if *v == nil { 462 sv = &DescribeAcceleratorTypesOutput{} 463 } else { 464 sv = *v 465 } 466 467 for key, value := range shape { 468 switch key { 469 case "acceleratorTypes": 470 if err := awsRestjson1_deserializeDocumentAcceleratorTypeList(&sv.AcceleratorTypes, value); err != nil { 471 return err 472 } 473 474 default: 475 _, _ = key, value 476 477 } 478 } 479 *v = sv 480 return nil 481} 482 483type awsRestjson1_deserializeOpListTagsForResource struct { 484} 485 486func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 487 return "OperationDeserializer" 488} 489 490func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 491 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 492) { 493 out, metadata, err = next.HandleDeserialize(ctx, in) 494 if err != nil { 495 return out, metadata, err 496 } 497 498 response, ok := out.RawResponse.(*smithyhttp.Response) 499 if !ok { 500 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 501 } 502 503 if response.StatusCode < 200 || response.StatusCode >= 300 { 504 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 505 } 506 output := &ListTagsForResourceOutput{} 507 out.Result = output 508 509 var buff [1024]byte 510 ringBuffer := smithyio.NewRingBuffer(buff[:]) 511 512 body := io.TeeReader(response.Body, ringBuffer) 513 514 decoder := json.NewDecoder(body) 515 decoder.UseNumber() 516 var shape interface{} 517 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 518 var snapshot bytes.Buffer 519 io.Copy(&snapshot, ringBuffer) 520 err = &smithy.DeserializationError{ 521 Err: fmt.Errorf("failed to decode response body, %w", err), 522 Snapshot: snapshot.Bytes(), 523 } 524 return out, metadata, err 525 } 526 527 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 528 if err != nil { 529 var snapshot bytes.Buffer 530 io.Copy(&snapshot, ringBuffer) 531 return out, metadata, &smithy.DeserializationError{ 532 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 533 Snapshot: snapshot.Bytes(), 534 } 535 } 536 537 return out, metadata, err 538} 539 540func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 541 var errorBuffer bytes.Buffer 542 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 543 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 544 } 545 errorBody := bytes.NewReader(errorBuffer.Bytes()) 546 547 errorCode := "UnknownError" 548 errorMessage := errorCode 549 550 code := response.Header.Get("X-Amzn-ErrorType") 551 if len(code) != 0 { 552 errorCode = restjson.SanitizeErrorCode(code) 553 } 554 555 var buff [1024]byte 556 ringBuffer := smithyio.NewRingBuffer(buff[:]) 557 558 body := io.TeeReader(errorBody, ringBuffer) 559 decoder := json.NewDecoder(body) 560 decoder.UseNumber() 561 code, message, err := restjson.GetErrorInfo(decoder) 562 if err != nil { 563 var snapshot bytes.Buffer 564 io.Copy(&snapshot, ringBuffer) 565 err = &smithy.DeserializationError{ 566 Err: fmt.Errorf("failed to decode response body, %w", err), 567 Snapshot: snapshot.Bytes(), 568 } 569 return err 570 } 571 572 errorBody.Seek(0, io.SeekStart) 573 if len(code) != 0 { 574 errorCode = restjson.SanitizeErrorCode(code) 575 } 576 if len(message) != 0 { 577 errorMessage = message 578 } 579 580 switch { 581 case strings.EqualFold("BadRequestException", errorCode): 582 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 583 584 case strings.EqualFold("InternalServerException", errorCode): 585 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 586 587 case strings.EqualFold("ResourceNotFoundException", errorCode): 588 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 589 590 default: 591 genericError := &smithy.GenericAPIError{ 592 Code: errorCode, 593 Message: errorMessage, 594 } 595 return genericError 596 597 } 598} 599 600func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 601 if v == nil { 602 return fmt.Errorf("unexpected nil of type %T", v) 603 } 604 if value == nil { 605 return nil 606 } 607 608 shape, ok := value.(map[string]interface{}) 609 if !ok { 610 return fmt.Errorf("unexpected JSON type %v", value) 611 } 612 613 var sv *ListTagsForResourceOutput 614 if *v == nil { 615 sv = &ListTagsForResourceOutput{} 616 } else { 617 sv = *v 618 } 619 620 for key, value := range shape { 621 switch key { 622 case "tags": 623 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 624 return err 625 } 626 627 default: 628 _, _ = key, value 629 630 } 631 } 632 *v = sv 633 return nil 634} 635 636type awsRestjson1_deserializeOpTagResource struct { 637} 638 639func (*awsRestjson1_deserializeOpTagResource) ID() string { 640 return "OperationDeserializer" 641} 642 643func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 644 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 645) { 646 out, metadata, err = next.HandleDeserialize(ctx, in) 647 if err != nil { 648 return out, metadata, err 649 } 650 651 response, ok := out.RawResponse.(*smithyhttp.Response) 652 if !ok { 653 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 654 } 655 656 if response.StatusCode < 200 || response.StatusCode >= 300 { 657 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 658 } 659 output := &TagResourceOutput{} 660 out.Result = output 661 662 return out, metadata, err 663} 664 665func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 666 var errorBuffer bytes.Buffer 667 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 668 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 669 } 670 errorBody := bytes.NewReader(errorBuffer.Bytes()) 671 672 errorCode := "UnknownError" 673 errorMessage := errorCode 674 675 code := response.Header.Get("X-Amzn-ErrorType") 676 if len(code) != 0 { 677 errorCode = restjson.SanitizeErrorCode(code) 678 } 679 680 var buff [1024]byte 681 ringBuffer := smithyio.NewRingBuffer(buff[:]) 682 683 body := io.TeeReader(errorBody, ringBuffer) 684 decoder := json.NewDecoder(body) 685 decoder.UseNumber() 686 code, message, err := restjson.GetErrorInfo(decoder) 687 if err != nil { 688 var snapshot bytes.Buffer 689 io.Copy(&snapshot, ringBuffer) 690 err = &smithy.DeserializationError{ 691 Err: fmt.Errorf("failed to decode response body, %w", err), 692 Snapshot: snapshot.Bytes(), 693 } 694 return err 695 } 696 697 errorBody.Seek(0, io.SeekStart) 698 if len(code) != 0 { 699 errorCode = restjson.SanitizeErrorCode(code) 700 } 701 if len(message) != 0 { 702 errorMessage = message 703 } 704 705 switch { 706 case strings.EqualFold("BadRequestException", errorCode): 707 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 708 709 case strings.EqualFold("InternalServerException", errorCode): 710 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 711 712 case strings.EqualFold("ResourceNotFoundException", errorCode): 713 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 714 715 default: 716 genericError := &smithy.GenericAPIError{ 717 Code: errorCode, 718 Message: errorMessage, 719 } 720 return genericError 721 722 } 723} 724 725type awsRestjson1_deserializeOpUntagResource struct { 726} 727 728func (*awsRestjson1_deserializeOpUntagResource) ID() string { 729 return "OperationDeserializer" 730} 731 732func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 733 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 734) { 735 out, metadata, err = next.HandleDeserialize(ctx, in) 736 if err != nil { 737 return out, metadata, err 738 } 739 740 response, ok := out.RawResponse.(*smithyhttp.Response) 741 if !ok { 742 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 743 } 744 745 if response.StatusCode < 200 || response.StatusCode >= 300 { 746 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 747 } 748 output := &UntagResourceOutput{} 749 out.Result = output 750 751 return out, metadata, err 752} 753 754func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 755 var errorBuffer bytes.Buffer 756 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 757 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 758 } 759 errorBody := bytes.NewReader(errorBuffer.Bytes()) 760 761 errorCode := "UnknownError" 762 errorMessage := errorCode 763 764 code := response.Header.Get("X-Amzn-ErrorType") 765 if len(code) != 0 { 766 errorCode = restjson.SanitizeErrorCode(code) 767 } 768 769 var buff [1024]byte 770 ringBuffer := smithyio.NewRingBuffer(buff[:]) 771 772 body := io.TeeReader(errorBody, ringBuffer) 773 decoder := json.NewDecoder(body) 774 decoder.UseNumber() 775 code, message, err := restjson.GetErrorInfo(decoder) 776 if err != nil { 777 var snapshot bytes.Buffer 778 io.Copy(&snapshot, ringBuffer) 779 err = &smithy.DeserializationError{ 780 Err: fmt.Errorf("failed to decode response body, %w", err), 781 Snapshot: snapshot.Bytes(), 782 } 783 return err 784 } 785 786 errorBody.Seek(0, io.SeekStart) 787 if len(code) != 0 { 788 errorCode = restjson.SanitizeErrorCode(code) 789 } 790 if len(message) != 0 { 791 errorMessage = message 792 } 793 794 switch { 795 case strings.EqualFold("BadRequestException", errorCode): 796 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 797 798 case strings.EqualFold("InternalServerException", errorCode): 799 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 800 801 case strings.EqualFold("ResourceNotFoundException", errorCode): 802 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 803 804 default: 805 genericError := &smithy.GenericAPIError{ 806 Code: errorCode, 807 Message: errorMessage, 808 } 809 return genericError 810 811 } 812} 813 814func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 815 output := &types.BadRequestException{} 816 var buff [1024]byte 817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 818 819 body := io.TeeReader(errorBody, ringBuffer) 820 decoder := json.NewDecoder(body) 821 decoder.UseNumber() 822 var shape interface{} 823 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 824 var snapshot bytes.Buffer 825 io.Copy(&snapshot, ringBuffer) 826 err = &smithy.DeserializationError{ 827 Err: fmt.Errorf("failed to decode response body, %w", err), 828 Snapshot: snapshot.Bytes(), 829 } 830 return err 831 } 832 833 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 834 835 if err != nil { 836 var snapshot bytes.Buffer 837 io.Copy(&snapshot, ringBuffer) 838 err = &smithy.DeserializationError{ 839 Err: fmt.Errorf("failed to decode response body, %w", err), 840 Snapshot: snapshot.Bytes(), 841 } 842 return err 843 } 844 845 errorBody.Seek(0, io.SeekStart) 846 847 return output 848} 849 850func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 851 output := &types.InternalServerException{} 852 var buff [1024]byte 853 ringBuffer := smithyio.NewRingBuffer(buff[:]) 854 855 body := io.TeeReader(errorBody, ringBuffer) 856 decoder := json.NewDecoder(body) 857 decoder.UseNumber() 858 var shape interface{} 859 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 860 var snapshot bytes.Buffer 861 io.Copy(&snapshot, ringBuffer) 862 err = &smithy.DeserializationError{ 863 Err: fmt.Errorf("failed to decode response body, %w", err), 864 Snapshot: snapshot.Bytes(), 865 } 866 return err 867 } 868 869 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape) 870 871 if err != nil { 872 var snapshot bytes.Buffer 873 io.Copy(&snapshot, ringBuffer) 874 err = &smithy.DeserializationError{ 875 Err: fmt.Errorf("failed to decode response body, %w", err), 876 Snapshot: snapshot.Bytes(), 877 } 878 return err 879 } 880 881 errorBody.Seek(0, io.SeekStart) 882 883 return output 884} 885 886func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 887 output := &types.ResourceNotFoundException{} 888 var buff [1024]byte 889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 890 891 body := io.TeeReader(errorBody, ringBuffer) 892 decoder := json.NewDecoder(body) 893 decoder.UseNumber() 894 var shape interface{} 895 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 896 var snapshot bytes.Buffer 897 io.Copy(&snapshot, ringBuffer) 898 err = &smithy.DeserializationError{ 899 Err: fmt.Errorf("failed to decode response body, %w", err), 900 Snapshot: snapshot.Bytes(), 901 } 902 return err 903 } 904 905 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 906 907 if err != nil { 908 var snapshot bytes.Buffer 909 io.Copy(&snapshot, ringBuffer) 910 err = &smithy.DeserializationError{ 911 Err: fmt.Errorf("failed to decode response body, %w", err), 912 Snapshot: snapshot.Bytes(), 913 } 914 return err 915 } 916 917 errorBody.Seek(0, io.SeekStart) 918 919 return output 920} 921 922func awsRestjson1_deserializeDocumentAcceleratorType(v **types.AcceleratorType, value interface{}) error { 923 if v == nil { 924 return fmt.Errorf("unexpected nil of type %T", v) 925 } 926 if value == nil { 927 return nil 928 } 929 930 shape, ok := value.(map[string]interface{}) 931 if !ok { 932 return fmt.Errorf("unexpected JSON type %v", value) 933 } 934 935 var sv *types.AcceleratorType 936 if *v == nil { 937 sv = &types.AcceleratorType{} 938 } else { 939 sv = *v 940 } 941 942 for key, value := range shape { 943 switch key { 944 case "acceleratorTypeName": 945 if value != nil { 946 jtv, ok := value.(string) 947 if !ok { 948 return fmt.Errorf("expected AcceleratorTypeName to be of type string, got %T instead", value) 949 } 950 sv.AcceleratorTypeName = ptr.String(jtv) 951 } 952 953 case "memoryInfo": 954 if err := awsRestjson1_deserializeDocumentMemoryInfo(&sv.MemoryInfo, value); err != nil { 955 return err 956 } 957 958 case "throughputInfo": 959 if err := awsRestjson1_deserializeDocumentThroughputInfoList(&sv.ThroughputInfo, value); err != nil { 960 return err 961 } 962 963 default: 964 _, _ = key, value 965 966 } 967 } 968 *v = sv 969 return nil 970} 971 972func awsRestjson1_deserializeDocumentAcceleratorTypeList(v *[]types.AcceleratorType, value interface{}) error { 973 if v == nil { 974 return fmt.Errorf("unexpected nil of type %T", v) 975 } 976 if value == nil { 977 return nil 978 } 979 980 shape, ok := value.([]interface{}) 981 if !ok { 982 return fmt.Errorf("unexpected JSON type %v", value) 983 } 984 985 var cv []types.AcceleratorType 986 if *v == nil { 987 cv = []types.AcceleratorType{} 988 } else { 989 cv = *v 990 } 991 992 for _, value := range shape { 993 var col types.AcceleratorType 994 destAddr := &col 995 if err := awsRestjson1_deserializeDocumentAcceleratorType(&destAddr, value); err != nil { 996 return err 997 } 998 col = *destAddr 999 cv = append(cv, col) 1000 1001 } 1002 *v = cv 1003 return nil 1004} 1005 1006func awsRestjson1_deserializeDocumentAcceleratorTypeOffering(v **types.AcceleratorTypeOffering, value interface{}) error { 1007 if v == nil { 1008 return fmt.Errorf("unexpected nil of type %T", v) 1009 } 1010 if value == nil { 1011 return nil 1012 } 1013 1014 shape, ok := value.(map[string]interface{}) 1015 if !ok { 1016 return fmt.Errorf("unexpected JSON type %v", value) 1017 } 1018 1019 var sv *types.AcceleratorTypeOffering 1020 if *v == nil { 1021 sv = &types.AcceleratorTypeOffering{} 1022 } else { 1023 sv = *v 1024 } 1025 1026 for key, value := range shape { 1027 switch key { 1028 case "acceleratorType": 1029 if value != nil { 1030 jtv, ok := value.(string) 1031 if !ok { 1032 return fmt.Errorf("expected AcceleratorTypeName to be of type string, got %T instead", value) 1033 } 1034 sv.AcceleratorType = ptr.String(jtv) 1035 } 1036 1037 case "location": 1038 if value != nil { 1039 jtv, ok := value.(string) 1040 if !ok { 1041 return fmt.Errorf("expected Location to be of type string, got %T instead", value) 1042 } 1043 sv.Location = ptr.String(jtv) 1044 } 1045 1046 case "locationType": 1047 if value != nil { 1048 jtv, ok := value.(string) 1049 if !ok { 1050 return fmt.Errorf("expected LocationType to be of type string, got %T instead", value) 1051 } 1052 sv.LocationType = types.LocationType(jtv) 1053 } 1054 1055 default: 1056 _, _ = key, value 1057 1058 } 1059 } 1060 *v = sv 1061 return nil 1062} 1063 1064func awsRestjson1_deserializeDocumentAcceleratorTypeOfferingList(v *[]types.AcceleratorTypeOffering, value interface{}) error { 1065 if v == nil { 1066 return fmt.Errorf("unexpected nil of type %T", v) 1067 } 1068 if value == nil { 1069 return nil 1070 } 1071 1072 shape, ok := value.([]interface{}) 1073 if !ok { 1074 return fmt.Errorf("unexpected JSON type %v", value) 1075 } 1076 1077 var cv []types.AcceleratorTypeOffering 1078 if *v == nil { 1079 cv = []types.AcceleratorTypeOffering{} 1080 } else { 1081 cv = *v 1082 } 1083 1084 for _, value := range shape { 1085 var col types.AcceleratorTypeOffering 1086 destAddr := &col 1087 if err := awsRestjson1_deserializeDocumentAcceleratorTypeOffering(&destAddr, value); err != nil { 1088 return err 1089 } 1090 col = *destAddr 1091 cv = append(cv, col) 1092 1093 } 1094 *v = cv 1095 return nil 1096} 1097 1098func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 1099 if v == nil { 1100 return fmt.Errorf("unexpected nil of type %T", v) 1101 } 1102 if value == nil { 1103 return nil 1104 } 1105 1106 shape, ok := value.(map[string]interface{}) 1107 if !ok { 1108 return fmt.Errorf("unexpected JSON type %v", value) 1109 } 1110 1111 var sv *types.BadRequestException 1112 if *v == nil { 1113 sv = &types.BadRequestException{} 1114 } else { 1115 sv = *v 1116 } 1117 1118 for key, value := range shape { 1119 switch key { 1120 case "message": 1121 if value != nil { 1122 jtv, ok := value.(string) 1123 if !ok { 1124 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1125 } 1126 sv.Message = ptr.String(jtv) 1127 } 1128 1129 default: 1130 _, _ = key, value 1131 1132 } 1133 } 1134 *v = sv 1135 return nil 1136} 1137 1138func awsRestjson1_deserializeDocumentElasticInferenceAccelerator(v **types.ElasticInferenceAccelerator, value interface{}) error { 1139 if v == nil { 1140 return fmt.Errorf("unexpected nil of type %T", v) 1141 } 1142 if value == nil { 1143 return nil 1144 } 1145 1146 shape, ok := value.(map[string]interface{}) 1147 if !ok { 1148 return fmt.Errorf("unexpected JSON type %v", value) 1149 } 1150 1151 var sv *types.ElasticInferenceAccelerator 1152 if *v == nil { 1153 sv = &types.ElasticInferenceAccelerator{} 1154 } else { 1155 sv = *v 1156 } 1157 1158 for key, value := range shape { 1159 switch key { 1160 case "acceleratorHealth": 1161 if err := awsRestjson1_deserializeDocumentElasticInferenceAcceleratorHealth(&sv.AcceleratorHealth, value); err != nil { 1162 return err 1163 } 1164 1165 case "acceleratorId": 1166 if value != nil { 1167 jtv, ok := value.(string) 1168 if !ok { 1169 return fmt.Errorf("expected AcceleratorId to be of type string, got %T instead", value) 1170 } 1171 sv.AcceleratorId = ptr.String(jtv) 1172 } 1173 1174 case "acceleratorType": 1175 if value != nil { 1176 jtv, ok := value.(string) 1177 if !ok { 1178 return fmt.Errorf("expected AcceleratorTypeName to be of type string, got %T instead", value) 1179 } 1180 sv.AcceleratorType = ptr.String(jtv) 1181 } 1182 1183 case "attachedResource": 1184 if value != nil { 1185 jtv, ok := value.(string) 1186 if !ok { 1187 return fmt.Errorf("expected ResourceARN2 to be of type string, got %T instead", value) 1188 } 1189 sv.AttachedResource = ptr.String(jtv) 1190 } 1191 1192 case "availabilityZone": 1193 if value != nil { 1194 jtv, ok := value.(string) 1195 if !ok { 1196 return fmt.Errorf("expected AvailabilityZone to be of type string, got %T instead", value) 1197 } 1198 sv.AvailabilityZone = ptr.String(jtv) 1199 } 1200 1201 default: 1202 _, _ = key, value 1203 1204 } 1205 } 1206 *v = sv 1207 return nil 1208} 1209 1210func awsRestjson1_deserializeDocumentElasticInferenceAcceleratorHealth(v **types.ElasticInferenceAcceleratorHealth, value interface{}) error { 1211 if v == nil { 1212 return fmt.Errorf("unexpected nil of type %T", v) 1213 } 1214 if value == nil { 1215 return nil 1216 } 1217 1218 shape, ok := value.(map[string]interface{}) 1219 if !ok { 1220 return fmt.Errorf("unexpected JSON type %v", value) 1221 } 1222 1223 var sv *types.ElasticInferenceAcceleratorHealth 1224 if *v == nil { 1225 sv = &types.ElasticInferenceAcceleratorHealth{} 1226 } else { 1227 sv = *v 1228 } 1229 1230 for key, value := range shape { 1231 switch key { 1232 case "status": 1233 if value != nil { 1234 jtv, ok := value.(string) 1235 if !ok { 1236 return fmt.Errorf("expected AcceleratorHealthStatus to be of type string, got %T instead", value) 1237 } 1238 sv.Status = ptr.String(jtv) 1239 } 1240 1241 default: 1242 _, _ = key, value 1243 1244 } 1245 } 1246 *v = sv 1247 return nil 1248} 1249 1250func awsRestjson1_deserializeDocumentElasticInferenceAcceleratorSet(v *[]types.ElasticInferenceAccelerator, value interface{}) error { 1251 if v == nil { 1252 return fmt.Errorf("unexpected nil of type %T", v) 1253 } 1254 if value == nil { 1255 return nil 1256 } 1257 1258 shape, ok := value.([]interface{}) 1259 if !ok { 1260 return fmt.Errorf("unexpected JSON type %v", value) 1261 } 1262 1263 var cv []types.ElasticInferenceAccelerator 1264 if *v == nil { 1265 cv = []types.ElasticInferenceAccelerator{} 1266 } else { 1267 cv = *v 1268 } 1269 1270 for _, value := range shape { 1271 var col types.ElasticInferenceAccelerator 1272 destAddr := &col 1273 if err := awsRestjson1_deserializeDocumentElasticInferenceAccelerator(&destAddr, value); err != nil { 1274 return err 1275 } 1276 col = *destAddr 1277 cv = append(cv, col) 1278 1279 } 1280 *v = cv 1281 return nil 1282} 1283 1284func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 1285 if v == nil { 1286 return fmt.Errorf("unexpected nil of type %T", v) 1287 } 1288 if value == nil { 1289 return nil 1290 } 1291 1292 shape, ok := value.(map[string]interface{}) 1293 if !ok { 1294 return fmt.Errorf("unexpected JSON type %v", value) 1295 } 1296 1297 var sv *types.InternalServerException 1298 if *v == nil { 1299 sv = &types.InternalServerException{} 1300 } else { 1301 sv = *v 1302 } 1303 1304 for key, value := range shape { 1305 switch key { 1306 case "message": 1307 if value != nil { 1308 jtv, ok := value.(string) 1309 if !ok { 1310 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1311 } 1312 sv.Message = ptr.String(jtv) 1313 } 1314 1315 default: 1316 _, _ = key, value 1317 1318 } 1319 } 1320 *v = sv 1321 return nil 1322} 1323 1324func awsRestjson1_deserializeDocumentKeyValuePair(v **types.KeyValuePair, value interface{}) error { 1325 if v == nil { 1326 return fmt.Errorf("unexpected nil of type %T", v) 1327 } 1328 if value == nil { 1329 return nil 1330 } 1331 1332 shape, ok := value.(map[string]interface{}) 1333 if !ok { 1334 return fmt.Errorf("unexpected JSON type %v", value) 1335 } 1336 1337 var sv *types.KeyValuePair 1338 if *v == nil { 1339 sv = &types.KeyValuePair{} 1340 } else { 1341 sv = *v 1342 } 1343 1344 for key, value := range shape { 1345 switch key { 1346 case "key": 1347 if value != nil { 1348 jtv, ok := value.(string) 1349 if !ok { 1350 return fmt.Errorf("expected Key to be of type string, got %T instead", value) 1351 } 1352 sv.Key = ptr.String(jtv) 1353 } 1354 1355 case "value": 1356 if value != nil { 1357 jtv, ok := value.(json.Number) 1358 if !ok { 1359 return fmt.Errorf("expected Value to be json.Number, got %T instead", value) 1360 } 1361 i64, err := jtv.Int64() 1362 if err != nil { 1363 return err 1364 } 1365 sv.Value = int32(i64) 1366 } 1367 1368 default: 1369 _, _ = key, value 1370 1371 } 1372 } 1373 *v = sv 1374 return nil 1375} 1376 1377func awsRestjson1_deserializeDocumentMemoryInfo(v **types.MemoryInfo, value interface{}) error { 1378 if v == nil { 1379 return fmt.Errorf("unexpected nil of type %T", v) 1380 } 1381 if value == nil { 1382 return nil 1383 } 1384 1385 shape, ok := value.(map[string]interface{}) 1386 if !ok { 1387 return fmt.Errorf("unexpected JSON type %v", value) 1388 } 1389 1390 var sv *types.MemoryInfo 1391 if *v == nil { 1392 sv = &types.MemoryInfo{} 1393 } else { 1394 sv = *v 1395 } 1396 1397 for key, value := range shape { 1398 switch key { 1399 case "sizeInMiB": 1400 if value != nil { 1401 jtv, ok := value.(json.Number) 1402 if !ok { 1403 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 1404 } 1405 i64, err := jtv.Int64() 1406 if err != nil { 1407 return err 1408 } 1409 sv.SizeInMiB = int32(i64) 1410 } 1411 1412 default: 1413 _, _ = key, value 1414 1415 } 1416 } 1417 *v = sv 1418 return nil 1419} 1420 1421func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 1422 if v == nil { 1423 return fmt.Errorf("unexpected nil of type %T", v) 1424 } 1425 if value == nil { 1426 return nil 1427 } 1428 1429 shape, ok := value.(map[string]interface{}) 1430 if !ok { 1431 return fmt.Errorf("unexpected JSON type %v", value) 1432 } 1433 1434 var sv *types.ResourceNotFoundException 1435 if *v == nil { 1436 sv = &types.ResourceNotFoundException{} 1437 } else { 1438 sv = *v 1439 } 1440 1441 for key, value := range shape { 1442 switch key { 1443 case "message": 1444 if value != nil { 1445 jtv, ok := value.(string) 1446 if !ok { 1447 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1448 } 1449 sv.Message = ptr.String(jtv) 1450 } 1451 1452 default: 1453 _, _ = key, value 1454 1455 } 1456 } 1457 *v = sv 1458 return nil 1459} 1460 1461func awsRestjson1_deserializeDocumentTagMap(v *map[string]string, value interface{}) error { 1462 if v == nil { 1463 return fmt.Errorf("unexpected nil of type %T", v) 1464 } 1465 if value == nil { 1466 return nil 1467 } 1468 1469 shape, ok := value.(map[string]interface{}) 1470 if !ok { 1471 return fmt.Errorf("unexpected JSON type %v", value) 1472 } 1473 1474 var mv map[string]string 1475 if *v == nil { 1476 mv = map[string]string{} 1477 } else { 1478 mv = *v 1479 } 1480 1481 for key, value := range shape { 1482 var parsedVal string 1483 if value != nil { 1484 jtv, ok := value.(string) 1485 if !ok { 1486 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 1487 } 1488 parsedVal = jtv 1489 } 1490 mv[key] = parsedVal 1491 1492 } 1493 *v = mv 1494 return nil 1495} 1496 1497func awsRestjson1_deserializeDocumentThroughputInfoList(v *[]types.KeyValuePair, value interface{}) error { 1498 if v == nil { 1499 return fmt.Errorf("unexpected nil of type %T", v) 1500 } 1501 if value == nil { 1502 return nil 1503 } 1504 1505 shape, ok := value.([]interface{}) 1506 if !ok { 1507 return fmt.Errorf("unexpected JSON type %v", value) 1508 } 1509 1510 var cv []types.KeyValuePair 1511 if *v == nil { 1512 cv = []types.KeyValuePair{} 1513 } else { 1514 cv = *v 1515 } 1516 1517 for _, value := range shape { 1518 var col types.KeyValuePair 1519 destAddr := &col 1520 if err := awsRestjson1_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 1521 return err 1522 } 1523 col = *destAddr 1524 cv = append(cv, col) 1525 1526 } 1527 *v = cv 1528 return nil 1529} 1530