1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package restxml 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/internal/protocoltest/restxml/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyxml "github.com/aws/smithy-go/encoding/xml" 13 "github.com/aws/smithy-go/middleware" 14 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16 "net/http" 17 "time" 18) 19 20type awsRestxml_serializeOpAllQueryStringTypes struct { 21} 22 23func (*awsRestxml_serializeOpAllQueryStringTypes) ID() string { 24 return "OperationSerializer" 25} 26 27func (m *awsRestxml_serializeOpAllQueryStringTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 28 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 29) { 30 request, ok := in.Request.(*smithyhttp.Request) 31 if !ok { 32 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 33 } 34 35 input, ok := in.Parameters.(*AllQueryStringTypesInput) 36 _ = input 37 if !ok { 38 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 39 } 40 41 opPath, opQuery := httpbinding.SplitURI("/AllQueryStringTypesInput") 42 request.URL.Path = opPath 43 if len(request.URL.RawQuery) > 0 { 44 request.URL.RawQuery = "&" + opQuery 45 } else { 46 request.URL.RawQuery = opQuery 47 } 48 49 request.Method = "GET" 50 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 51 if err != nil { 52 return out, metadata, &smithy.SerializationError{Err: err} 53 } 54 55 if err := awsRestxml_serializeOpHttpBindingsAllQueryStringTypesInput(input, restEncoder); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 in.Request = request 63 64 return next.HandleSerialize(ctx, in) 65} 66func awsRestxml_serializeOpHttpBindingsAllQueryStringTypesInput(v *AllQueryStringTypesInput, encoder *httpbinding.Encoder) error { 67 if v == nil { 68 return fmt.Errorf("unsupported serialization of nil %T", v) 69 } 70 71 if v.QueryBoolean != nil { 72 encoder.SetQuery("Boolean").Boolean(*v.QueryBoolean) 73 } 74 75 if v.QueryBooleanList != nil { 76 for i := range v.QueryBooleanList { 77 encoder.AddQuery("BooleanList").Boolean(v.QueryBooleanList[i]) 78 } 79 } 80 81 if v.QueryByte != nil { 82 encoder.SetQuery("Byte").Byte(*v.QueryByte) 83 } 84 85 if v.QueryDouble != nil { 86 encoder.SetQuery("Double").Double(*v.QueryDouble) 87 } 88 89 if v.QueryDoubleList != nil { 90 for i := range v.QueryDoubleList { 91 encoder.AddQuery("DoubleList").Double(v.QueryDoubleList[i]) 92 } 93 } 94 95 if len(v.QueryEnum) > 0 { 96 encoder.SetQuery("Enum").String(string(v.QueryEnum)) 97 } 98 99 if v.QueryEnumList != nil { 100 for i := range v.QueryEnumList { 101 encoder.AddQuery("EnumList").String(string(v.QueryEnumList[i])) 102 } 103 } 104 105 if v.QueryFloat != nil { 106 encoder.SetQuery("Float").Float(*v.QueryFloat) 107 } 108 109 if v.QueryInteger != nil { 110 encoder.SetQuery("Integer").Integer(*v.QueryInteger) 111 } 112 113 if v.QueryIntegerList != nil { 114 for i := range v.QueryIntegerList { 115 encoder.AddQuery("IntegerList").Integer(v.QueryIntegerList[i]) 116 } 117 } 118 119 if v.QueryIntegerSet != nil { 120 for i := range v.QueryIntegerSet { 121 encoder.AddQuery("IntegerSet").Integer(v.QueryIntegerSet[i]) 122 } 123 } 124 125 if v.QueryLong != nil { 126 encoder.SetQuery("Long").Long(*v.QueryLong) 127 } 128 129 if v.QueryShort != nil { 130 encoder.SetQuery("Short").Short(*v.QueryShort) 131 } 132 133 if v.QueryString != nil { 134 encoder.SetQuery("String").String(*v.QueryString) 135 } 136 137 if v.QueryStringList != nil { 138 for i := range v.QueryStringList { 139 encoder.AddQuery("StringList").String(v.QueryStringList[i]) 140 } 141 } 142 143 if v.QueryStringSet != nil { 144 for i := range v.QueryStringSet { 145 encoder.AddQuery("StringSet").String(v.QueryStringSet[i]) 146 } 147 } 148 149 if v.QueryTimestamp != nil { 150 encoder.SetQuery("Timestamp").String(smithytime.FormatDateTime(*v.QueryTimestamp)) 151 } 152 153 if v.QueryTimestampList != nil { 154 for i := range v.QueryTimestampList { 155 encoder.AddQuery("TimestampList").String(smithytime.FormatDateTime(v.QueryTimestampList[i])) 156 } 157 } 158 159 return nil 160} 161 162type awsRestxml_serializeOpConstantAndVariableQueryString struct { 163} 164 165func (*awsRestxml_serializeOpConstantAndVariableQueryString) ID() string { 166 return "OperationSerializer" 167} 168 169func (m *awsRestxml_serializeOpConstantAndVariableQueryString) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 170 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 171) { 172 request, ok := in.Request.(*smithyhttp.Request) 173 if !ok { 174 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 175 } 176 177 input, ok := in.Parameters.(*ConstantAndVariableQueryStringInput) 178 _ = input 179 if !ok { 180 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 181 } 182 183 opPath, opQuery := httpbinding.SplitURI("/ConstantAndVariableQueryString?foo=bar") 184 request.URL.Path = opPath 185 if len(request.URL.RawQuery) > 0 { 186 request.URL.RawQuery = "&" + opQuery 187 } else { 188 request.URL.RawQuery = opQuery 189 } 190 191 request.Method = "GET" 192 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 193 if err != nil { 194 return out, metadata, &smithy.SerializationError{Err: err} 195 } 196 197 if err := awsRestxml_serializeOpHttpBindingsConstantAndVariableQueryStringInput(input, restEncoder); err != nil { 198 return out, metadata, &smithy.SerializationError{Err: err} 199 } 200 201 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 202 return out, metadata, &smithy.SerializationError{Err: err} 203 } 204 in.Request = request 205 206 return next.HandleSerialize(ctx, in) 207} 208func awsRestxml_serializeOpHttpBindingsConstantAndVariableQueryStringInput(v *ConstantAndVariableQueryStringInput, encoder *httpbinding.Encoder) error { 209 if v == nil { 210 return fmt.Errorf("unsupported serialization of nil %T", v) 211 } 212 213 if v.Baz != nil { 214 encoder.SetQuery("baz").String(*v.Baz) 215 } 216 217 if v.MaybeSet != nil { 218 encoder.SetQuery("maybeSet").String(*v.MaybeSet) 219 } 220 221 return nil 222} 223 224type awsRestxml_serializeOpConstantQueryString struct { 225} 226 227func (*awsRestxml_serializeOpConstantQueryString) ID() string { 228 return "OperationSerializer" 229} 230 231func (m *awsRestxml_serializeOpConstantQueryString) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 232 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 233) { 234 request, ok := in.Request.(*smithyhttp.Request) 235 if !ok { 236 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 237 } 238 239 input, ok := in.Parameters.(*ConstantQueryStringInput) 240 _ = input 241 if !ok { 242 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 243 } 244 245 opPath, opQuery := httpbinding.SplitURI("/ConstantQueryString/{hello}?foo=bar&hello") 246 request.URL.Path = opPath 247 if len(request.URL.RawQuery) > 0 { 248 request.URL.RawQuery = "&" + opQuery 249 } else { 250 request.URL.RawQuery = opQuery 251 } 252 253 request.Method = "GET" 254 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 255 if err != nil { 256 return out, metadata, &smithy.SerializationError{Err: err} 257 } 258 259 if err := awsRestxml_serializeOpHttpBindingsConstantQueryStringInput(input, restEncoder); err != nil { 260 return out, metadata, &smithy.SerializationError{Err: err} 261 } 262 263 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 264 return out, metadata, &smithy.SerializationError{Err: err} 265 } 266 in.Request = request 267 268 return next.HandleSerialize(ctx, in) 269} 270func awsRestxml_serializeOpHttpBindingsConstantQueryStringInput(v *ConstantQueryStringInput, encoder *httpbinding.Encoder) error { 271 if v == nil { 272 return fmt.Errorf("unsupported serialization of nil %T", v) 273 } 274 275 if v.Hello == nil || len(*v.Hello) == 0 { 276 return &smithy.SerializationError{Err: fmt.Errorf("input member hello must not be empty")} 277 } 278 if v.Hello != nil { 279 if err := encoder.SetURI("hello").String(*v.Hello); err != nil { 280 return err 281 } 282 } 283 284 return nil 285} 286 287type awsRestxml_serializeOpEmptyInputAndEmptyOutput struct { 288} 289 290func (*awsRestxml_serializeOpEmptyInputAndEmptyOutput) ID() string { 291 return "OperationSerializer" 292} 293 294func (m *awsRestxml_serializeOpEmptyInputAndEmptyOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 295 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 296) { 297 request, ok := in.Request.(*smithyhttp.Request) 298 if !ok { 299 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 300 } 301 302 input, ok := in.Parameters.(*EmptyInputAndEmptyOutputInput) 303 _ = input 304 if !ok { 305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 306 } 307 308 opPath, opQuery := httpbinding.SplitURI("/EmptyInputAndEmptyOutput") 309 request.URL.Path = opPath 310 if len(request.URL.RawQuery) > 0 { 311 request.URL.RawQuery = "&" + opQuery 312 } else { 313 request.URL.RawQuery = opQuery 314 } 315 316 request.Method = "POST" 317 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 318 if err != nil { 319 return out, metadata, &smithy.SerializationError{Err: err} 320 } 321 322 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 323 return out, metadata, &smithy.SerializationError{Err: err} 324 } 325 in.Request = request 326 327 return next.HandleSerialize(ctx, in) 328} 329func awsRestxml_serializeOpHttpBindingsEmptyInputAndEmptyOutputInput(v *EmptyInputAndEmptyOutputInput, encoder *httpbinding.Encoder) error { 330 if v == nil { 331 return fmt.Errorf("unsupported serialization of nil %T", v) 332 } 333 334 return nil 335} 336 337type awsRestxml_serializeOpFlattenedXmlMap struct { 338} 339 340func (*awsRestxml_serializeOpFlattenedXmlMap) ID() string { 341 return "OperationSerializer" 342} 343 344func (m *awsRestxml_serializeOpFlattenedXmlMap) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 345 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 346) { 347 request, ok := in.Request.(*smithyhttp.Request) 348 if !ok { 349 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 350 } 351 352 input, ok := in.Parameters.(*FlattenedXmlMapInput) 353 _ = input 354 if !ok { 355 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 356 } 357 358 opPath, opQuery := httpbinding.SplitURI("/FlattenedXmlMap") 359 request.URL.Path = opPath 360 if len(request.URL.RawQuery) > 0 { 361 request.URL.RawQuery = "&" + opQuery 362 } else { 363 request.URL.RawQuery = opQuery 364 } 365 366 request.Method = "POST" 367 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 368 if err != nil { 369 return out, metadata, &smithy.SerializationError{Err: err} 370 } 371 372 restEncoder.SetHeader("Content-Type").String("application/xml") 373 374 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 375 rootAttr := []smithyxml.Attr{} 376 root := smithyxml.StartElement{ 377 Name: smithyxml.Name{ 378 Local: "FlattenedXmlMapInputOutput", 379 }, 380 Attr: rootAttr, 381 } 382 if err := awsRestxml_serializeOpDocumentFlattenedXmlMapInput(input, xmlEncoder.RootElement(root)); err != nil { 383 return out, metadata, &smithy.SerializationError{Err: err} 384 } 385 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 386 return out, metadata, &smithy.SerializationError{Err: err} 387 } 388 389 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 390 return out, metadata, &smithy.SerializationError{Err: err} 391 } 392 in.Request = request 393 394 return next.HandleSerialize(ctx, in) 395} 396func awsRestxml_serializeOpHttpBindingsFlattenedXmlMapInput(v *FlattenedXmlMapInput, encoder *httpbinding.Encoder) error { 397 if v == nil { 398 return fmt.Errorf("unsupported serialization of nil %T", v) 399 } 400 401 return nil 402} 403 404func awsRestxml_serializeOpDocumentFlattenedXmlMapInput(v *FlattenedXmlMapInput, value smithyxml.Value) error { 405 defer value.Close() 406 if v.MyMap != nil { 407 rootAttr := []smithyxml.Attr{} 408 root := smithyxml.StartElement{ 409 Name: smithyxml.Name{ 410 Local: "myMap", 411 }, 412 Attr: rootAttr, 413 } 414 el := value.FlattenedElement(root) 415 if err := awsRestxml_serializeDocumentFooEnumMap(v.MyMap, el); err != nil { 416 return err 417 } 418 } 419 return nil 420} 421 422type awsRestxml_serializeOpFlattenedXmlMapWithXmlName struct { 423} 424 425func (*awsRestxml_serializeOpFlattenedXmlMapWithXmlName) ID() string { 426 return "OperationSerializer" 427} 428 429func (m *awsRestxml_serializeOpFlattenedXmlMapWithXmlName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 430 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 431) { 432 request, ok := in.Request.(*smithyhttp.Request) 433 if !ok { 434 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 435 } 436 437 input, ok := in.Parameters.(*FlattenedXmlMapWithXmlNameInput) 438 _ = input 439 if !ok { 440 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 441 } 442 443 opPath, opQuery := httpbinding.SplitURI("/FlattenedXmlMapWithXmlName") 444 request.URL.Path = opPath 445 if len(request.URL.RawQuery) > 0 { 446 request.URL.RawQuery = "&" + opQuery 447 } else { 448 request.URL.RawQuery = opQuery 449 } 450 451 request.Method = "POST" 452 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 453 if err != nil { 454 return out, metadata, &smithy.SerializationError{Err: err} 455 } 456 457 restEncoder.SetHeader("Content-Type").String("application/xml") 458 459 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 460 rootAttr := []smithyxml.Attr{} 461 root := smithyxml.StartElement{ 462 Name: smithyxml.Name{ 463 Local: "FlattenedXmlMapWithXmlNameInputOutput", 464 }, 465 Attr: rootAttr, 466 } 467 if err := awsRestxml_serializeOpDocumentFlattenedXmlMapWithXmlNameInput(input, xmlEncoder.RootElement(root)); err != nil { 468 return out, metadata, &smithy.SerializationError{Err: err} 469 } 470 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 471 return out, metadata, &smithy.SerializationError{Err: err} 472 } 473 474 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 475 return out, metadata, &smithy.SerializationError{Err: err} 476 } 477 in.Request = request 478 479 return next.HandleSerialize(ctx, in) 480} 481func awsRestxml_serializeOpHttpBindingsFlattenedXmlMapWithXmlNameInput(v *FlattenedXmlMapWithXmlNameInput, encoder *httpbinding.Encoder) error { 482 if v == nil { 483 return fmt.Errorf("unsupported serialization of nil %T", v) 484 } 485 486 return nil 487} 488 489func awsRestxml_serializeOpDocumentFlattenedXmlMapWithXmlNameInput(v *FlattenedXmlMapWithXmlNameInput, value smithyxml.Value) error { 490 defer value.Close() 491 if v.MyMap != nil { 492 rootAttr := []smithyxml.Attr{} 493 root := smithyxml.StartElement{ 494 Name: smithyxml.Name{ 495 Local: "KVP", 496 }, 497 Attr: rootAttr, 498 } 499 el := value.FlattenedElement(root) 500 if err := awsRestxml_serializeDocumentFlattenedXmlMapWithXmlNameInputOutputMap(v.MyMap, el); err != nil { 501 return err 502 } 503 } 504 return nil 505} 506 507type awsRestxml_serializeOpFlattenedXmlMapWithXmlNamespace struct { 508} 509 510func (*awsRestxml_serializeOpFlattenedXmlMapWithXmlNamespace) ID() string { 511 return "OperationSerializer" 512} 513 514func (m *awsRestxml_serializeOpFlattenedXmlMapWithXmlNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 515 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 516) { 517 request, ok := in.Request.(*smithyhttp.Request) 518 if !ok { 519 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 520 } 521 522 input, ok := in.Parameters.(*FlattenedXmlMapWithXmlNamespaceInput) 523 _ = input 524 if !ok { 525 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 526 } 527 528 opPath, opQuery := httpbinding.SplitURI("/FlattenedXmlMapWithXmlNamespace") 529 request.URL.Path = opPath 530 if len(request.URL.RawQuery) > 0 { 531 request.URL.RawQuery = "&" + opQuery 532 } else { 533 request.URL.RawQuery = opQuery 534 } 535 536 request.Method = "POST" 537 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 538 if err != nil { 539 return out, metadata, &smithy.SerializationError{Err: err} 540 } 541 542 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 543 return out, metadata, &smithy.SerializationError{Err: err} 544 } 545 in.Request = request 546 547 return next.HandleSerialize(ctx, in) 548} 549func awsRestxml_serializeOpHttpBindingsFlattenedXmlMapWithXmlNamespaceInput(v *FlattenedXmlMapWithXmlNamespaceInput, encoder *httpbinding.Encoder) error { 550 if v == nil { 551 return fmt.Errorf("unsupported serialization of nil %T", v) 552 } 553 554 return nil 555} 556 557type awsRestxml_serializeOpGreetingWithErrors struct { 558} 559 560func (*awsRestxml_serializeOpGreetingWithErrors) ID() string { 561 return "OperationSerializer" 562} 563 564func (m *awsRestxml_serializeOpGreetingWithErrors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 565 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 566) { 567 request, ok := in.Request.(*smithyhttp.Request) 568 if !ok { 569 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 570 } 571 572 input, ok := in.Parameters.(*GreetingWithErrorsInput) 573 _ = input 574 if !ok { 575 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 576 } 577 578 opPath, opQuery := httpbinding.SplitURI("/GreetingWithErrors") 579 request.URL.Path = opPath 580 if len(request.URL.RawQuery) > 0 { 581 request.URL.RawQuery = "&" + opQuery 582 } else { 583 request.URL.RawQuery = opQuery 584 } 585 586 request.Method = "PUT" 587 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 588 if err != nil { 589 return out, metadata, &smithy.SerializationError{Err: err} 590 } 591 592 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 593 return out, metadata, &smithy.SerializationError{Err: err} 594 } 595 in.Request = request 596 597 return next.HandleSerialize(ctx, in) 598} 599func awsRestxml_serializeOpHttpBindingsGreetingWithErrorsInput(v *GreetingWithErrorsInput, encoder *httpbinding.Encoder) error { 600 if v == nil { 601 return fmt.Errorf("unsupported serialization of nil %T", v) 602 } 603 604 return nil 605} 606 607type awsRestxml_serializeOpHttpPayloadTraits struct { 608} 609 610func (*awsRestxml_serializeOpHttpPayloadTraits) ID() string { 611 return "OperationSerializer" 612} 613 614func (m *awsRestxml_serializeOpHttpPayloadTraits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 615 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 616) { 617 request, ok := in.Request.(*smithyhttp.Request) 618 if !ok { 619 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 620 } 621 622 input, ok := in.Parameters.(*HttpPayloadTraitsInput) 623 _ = input 624 if !ok { 625 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 626 } 627 628 opPath, opQuery := httpbinding.SplitURI("/HttpPayloadTraits") 629 request.URL.Path = opPath 630 if len(request.URL.RawQuery) > 0 { 631 request.URL.RawQuery = "&" + opQuery 632 } else { 633 request.URL.RawQuery = opQuery 634 } 635 636 request.Method = "POST" 637 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 638 if err != nil { 639 return out, metadata, &smithy.SerializationError{Err: err} 640 } 641 642 if err := awsRestxml_serializeOpHttpBindingsHttpPayloadTraitsInput(input, restEncoder); err != nil { 643 return out, metadata, &smithy.SerializationError{Err: err} 644 } 645 646 if input.Blob != nil { 647 if !restEncoder.HasHeader("Content-Type") { 648 restEncoder.SetHeader("Content-Type").String("application/octet-stream") 649 } 650 651 payload := bytes.NewReader(input.Blob) 652 if request, err = request.SetStream(payload); err != nil { 653 return out, metadata, &smithy.SerializationError{Err: err} 654 } 655 } 656 657 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 658 return out, metadata, &smithy.SerializationError{Err: err} 659 } 660 in.Request = request 661 662 return next.HandleSerialize(ctx, in) 663} 664func awsRestxml_serializeOpHttpBindingsHttpPayloadTraitsInput(v *HttpPayloadTraitsInput, encoder *httpbinding.Encoder) error { 665 if v == nil { 666 return fmt.Errorf("unsupported serialization of nil %T", v) 667 } 668 669 if v.Foo != nil && len(*v.Foo) > 0 { 670 locationName := "X-Foo" 671 encoder.SetHeader(locationName).String(*v.Foo) 672 } 673 674 return nil 675} 676 677type awsRestxml_serializeOpHttpPayloadTraitsWithMediaType struct { 678} 679 680func (*awsRestxml_serializeOpHttpPayloadTraitsWithMediaType) ID() string { 681 return "OperationSerializer" 682} 683 684func (m *awsRestxml_serializeOpHttpPayloadTraitsWithMediaType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 685 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 686) { 687 request, ok := in.Request.(*smithyhttp.Request) 688 if !ok { 689 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 690 } 691 692 input, ok := in.Parameters.(*HttpPayloadTraitsWithMediaTypeInput) 693 _ = input 694 if !ok { 695 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 696 } 697 698 opPath, opQuery := httpbinding.SplitURI("/HttpPayloadTraitsWithMediaType") 699 request.URL.Path = opPath 700 if len(request.URL.RawQuery) > 0 { 701 request.URL.RawQuery = "&" + opQuery 702 } else { 703 request.URL.RawQuery = opQuery 704 } 705 706 request.Method = "POST" 707 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 708 if err != nil { 709 return out, metadata, &smithy.SerializationError{Err: err} 710 } 711 712 if err := awsRestxml_serializeOpHttpBindingsHttpPayloadTraitsWithMediaTypeInput(input, restEncoder); err != nil { 713 return out, metadata, &smithy.SerializationError{Err: err} 714 } 715 716 if input.Blob != nil { 717 if !restEncoder.HasHeader("Content-Type") { 718 restEncoder.SetHeader("Content-Type").String("text/plain") 719 } 720 721 payload := bytes.NewReader(input.Blob) 722 if request, err = request.SetStream(payload); err != nil { 723 return out, metadata, &smithy.SerializationError{Err: err} 724 } 725 } 726 727 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 728 return out, metadata, &smithy.SerializationError{Err: err} 729 } 730 in.Request = request 731 732 return next.HandleSerialize(ctx, in) 733} 734func awsRestxml_serializeOpHttpBindingsHttpPayloadTraitsWithMediaTypeInput(v *HttpPayloadTraitsWithMediaTypeInput, encoder *httpbinding.Encoder) error { 735 if v == nil { 736 return fmt.Errorf("unsupported serialization of nil %T", v) 737 } 738 739 if v.Foo != nil && len(*v.Foo) > 0 { 740 locationName := "X-Foo" 741 encoder.SetHeader(locationName).String(*v.Foo) 742 } 743 744 return nil 745} 746 747type awsRestxml_serializeOpHttpPayloadWithStructure struct { 748} 749 750func (*awsRestxml_serializeOpHttpPayloadWithStructure) ID() string { 751 return "OperationSerializer" 752} 753 754func (m *awsRestxml_serializeOpHttpPayloadWithStructure) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 755 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 756) { 757 request, ok := in.Request.(*smithyhttp.Request) 758 if !ok { 759 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 760 } 761 762 input, ok := in.Parameters.(*HttpPayloadWithStructureInput) 763 _ = input 764 if !ok { 765 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 766 } 767 768 opPath, opQuery := httpbinding.SplitURI("/HttpPayloadWithStructure") 769 request.URL.Path = opPath 770 if len(request.URL.RawQuery) > 0 { 771 request.URL.RawQuery = "&" + opQuery 772 } else { 773 request.URL.RawQuery = opQuery 774 } 775 776 request.Method = "PUT" 777 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 778 if err != nil { 779 return out, metadata, &smithy.SerializationError{Err: err} 780 } 781 782 if input.Nested != nil { 783 if !restEncoder.HasHeader("Content-Type") { 784 restEncoder.SetHeader("Content-Type").String("application/xml") 785 } 786 787 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 788 payloadRootAttr := []smithyxml.Attr{} 789 payloadRoot := smithyxml.StartElement{ 790 Name: smithyxml.Name{ 791 Local: "NestedPayload", 792 }, 793 Attr: payloadRootAttr, 794 } 795 if err := awsRestxml_serializeDocumentNestedPayload(input.Nested, xmlEncoder.RootElement(payloadRoot)); err != nil { 796 return out, metadata, &smithy.SerializationError{Err: err} 797 } 798 payload := bytes.NewReader(xmlEncoder.Bytes()) 799 if request, err = request.SetStream(payload); err != nil { 800 return out, metadata, &smithy.SerializationError{Err: err} 801 } 802 } 803 804 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 805 return out, metadata, &smithy.SerializationError{Err: err} 806 } 807 in.Request = request 808 809 return next.HandleSerialize(ctx, in) 810} 811func awsRestxml_serializeOpHttpBindingsHttpPayloadWithStructureInput(v *HttpPayloadWithStructureInput, encoder *httpbinding.Encoder) error { 812 if v == nil { 813 return fmt.Errorf("unsupported serialization of nil %T", v) 814 } 815 816 return nil 817} 818 819type awsRestxml_serializeOpHttpPayloadWithXmlName struct { 820} 821 822func (*awsRestxml_serializeOpHttpPayloadWithXmlName) ID() string { 823 return "OperationSerializer" 824} 825 826func (m *awsRestxml_serializeOpHttpPayloadWithXmlName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 827 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 828) { 829 request, ok := in.Request.(*smithyhttp.Request) 830 if !ok { 831 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 832 } 833 834 input, ok := in.Parameters.(*HttpPayloadWithXmlNameInput) 835 _ = input 836 if !ok { 837 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 838 } 839 840 opPath, opQuery := httpbinding.SplitURI("/HttpPayloadWithXmlName") 841 request.URL.Path = opPath 842 if len(request.URL.RawQuery) > 0 { 843 request.URL.RawQuery = "&" + opQuery 844 } else { 845 request.URL.RawQuery = opQuery 846 } 847 848 request.Method = "PUT" 849 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 850 if err != nil { 851 return out, metadata, &smithy.SerializationError{Err: err} 852 } 853 854 if input.Nested != nil { 855 if !restEncoder.HasHeader("Content-Type") { 856 restEncoder.SetHeader("Content-Type").String("application/xml") 857 } 858 859 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 860 payloadRootAttr := []smithyxml.Attr{} 861 payloadRoot := smithyxml.StartElement{ 862 Name: smithyxml.Name{ 863 Local: "Hello", 864 }, 865 Attr: payloadRootAttr, 866 } 867 if err := awsRestxml_serializeDocumentPayloadWithXmlName(input.Nested, xmlEncoder.RootElement(payloadRoot)); err != nil { 868 return out, metadata, &smithy.SerializationError{Err: err} 869 } 870 payload := bytes.NewReader(xmlEncoder.Bytes()) 871 if request, err = request.SetStream(payload); err != nil { 872 return out, metadata, &smithy.SerializationError{Err: err} 873 } 874 } 875 876 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 877 return out, metadata, &smithy.SerializationError{Err: err} 878 } 879 in.Request = request 880 881 return next.HandleSerialize(ctx, in) 882} 883func awsRestxml_serializeOpHttpBindingsHttpPayloadWithXmlNameInput(v *HttpPayloadWithXmlNameInput, encoder *httpbinding.Encoder) error { 884 if v == nil { 885 return fmt.Errorf("unsupported serialization of nil %T", v) 886 } 887 888 return nil 889} 890 891type awsRestxml_serializeOpHttpPayloadWithXmlNamespace struct { 892} 893 894func (*awsRestxml_serializeOpHttpPayloadWithXmlNamespace) ID() string { 895 return "OperationSerializer" 896} 897 898func (m *awsRestxml_serializeOpHttpPayloadWithXmlNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 899 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 900) { 901 request, ok := in.Request.(*smithyhttp.Request) 902 if !ok { 903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 904 } 905 906 input, ok := in.Parameters.(*HttpPayloadWithXmlNamespaceInput) 907 _ = input 908 if !ok { 909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 910 } 911 912 opPath, opQuery := httpbinding.SplitURI("/HttpPayloadWithXmlNamespace") 913 request.URL.Path = opPath 914 if len(request.URL.RawQuery) > 0 { 915 request.URL.RawQuery = "&" + opQuery 916 } else { 917 request.URL.RawQuery = opQuery 918 } 919 920 request.Method = "PUT" 921 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 922 if err != nil { 923 return out, metadata, &smithy.SerializationError{Err: err} 924 } 925 926 if input.Nested != nil { 927 if !restEncoder.HasHeader("Content-Type") { 928 restEncoder.SetHeader("Content-Type").String("application/xml") 929 } 930 931 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 932 payloadRootAttr := []smithyxml.Attr{} 933 payloadRootAttr = append(payloadRootAttr, smithyxml.NewNamespaceAttribute("", "http://foo.com")) 934 payloadRoot := smithyxml.StartElement{ 935 Name: smithyxml.Name{ 936 Local: "PayloadWithXmlNamespace", 937 }, 938 Attr: payloadRootAttr, 939 } 940 if err := awsRestxml_serializeDocumentPayloadWithXmlNamespace(input.Nested, xmlEncoder.RootElement(payloadRoot)); err != nil { 941 return out, metadata, &smithy.SerializationError{Err: err} 942 } 943 payload := bytes.NewReader(xmlEncoder.Bytes()) 944 if request, err = request.SetStream(payload); err != nil { 945 return out, metadata, &smithy.SerializationError{Err: err} 946 } 947 } 948 949 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 950 return out, metadata, &smithy.SerializationError{Err: err} 951 } 952 in.Request = request 953 954 return next.HandleSerialize(ctx, in) 955} 956func awsRestxml_serializeOpHttpBindingsHttpPayloadWithXmlNamespaceInput(v *HttpPayloadWithXmlNamespaceInput, encoder *httpbinding.Encoder) error { 957 if v == nil { 958 return fmt.Errorf("unsupported serialization of nil %T", v) 959 } 960 961 return nil 962} 963 964type awsRestxml_serializeOpHttpPayloadWithXmlNamespaceAndPrefix struct { 965} 966 967func (*awsRestxml_serializeOpHttpPayloadWithXmlNamespaceAndPrefix) ID() string { 968 return "OperationSerializer" 969} 970 971func (m *awsRestxml_serializeOpHttpPayloadWithXmlNamespaceAndPrefix) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 972 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 973) { 974 request, ok := in.Request.(*smithyhttp.Request) 975 if !ok { 976 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 977 } 978 979 input, ok := in.Parameters.(*HttpPayloadWithXmlNamespaceAndPrefixInput) 980 _ = input 981 if !ok { 982 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 983 } 984 985 opPath, opQuery := httpbinding.SplitURI("/HttpPayloadWithXmlNamespaceAndPrefix") 986 request.URL.Path = opPath 987 if len(request.URL.RawQuery) > 0 { 988 request.URL.RawQuery = "&" + opQuery 989 } else { 990 request.URL.RawQuery = opQuery 991 } 992 993 request.Method = "PUT" 994 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 995 if err != nil { 996 return out, metadata, &smithy.SerializationError{Err: err} 997 } 998 999 if input.Nested != nil { 1000 if !restEncoder.HasHeader("Content-Type") { 1001 restEncoder.SetHeader("Content-Type").String("application/xml") 1002 } 1003 1004 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1005 payloadRootAttr := []smithyxml.Attr{} 1006 payloadRootAttr = append(payloadRootAttr, smithyxml.NewNamespaceAttribute("baz", "http://foo.com")) 1007 payloadRoot := smithyxml.StartElement{ 1008 Name: smithyxml.Name{ 1009 Local: "PayloadWithXmlNamespaceAndPrefix", 1010 }, 1011 Attr: payloadRootAttr, 1012 } 1013 if err := awsRestxml_serializeDocumentPayloadWithXmlNamespaceAndPrefix(input.Nested, xmlEncoder.RootElement(payloadRoot)); err != nil { 1014 return out, metadata, &smithy.SerializationError{Err: err} 1015 } 1016 payload := bytes.NewReader(xmlEncoder.Bytes()) 1017 if request, err = request.SetStream(payload); err != nil { 1018 return out, metadata, &smithy.SerializationError{Err: err} 1019 } 1020 } 1021 1022 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1023 return out, metadata, &smithy.SerializationError{Err: err} 1024 } 1025 in.Request = request 1026 1027 return next.HandleSerialize(ctx, in) 1028} 1029func awsRestxml_serializeOpHttpBindingsHttpPayloadWithXmlNamespaceAndPrefixInput(v *HttpPayloadWithXmlNamespaceAndPrefixInput, encoder *httpbinding.Encoder) error { 1030 if v == nil { 1031 return fmt.Errorf("unsupported serialization of nil %T", v) 1032 } 1033 1034 return nil 1035} 1036 1037type awsRestxml_serializeOpHttpPrefixHeaders struct { 1038} 1039 1040func (*awsRestxml_serializeOpHttpPrefixHeaders) ID() string { 1041 return "OperationSerializer" 1042} 1043 1044func (m *awsRestxml_serializeOpHttpPrefixHeaders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1045 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1046) { 1047 request, ok := in.Request.(*smithyhttp.Request) 1048 if !ok { 1049 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1050 } 1051 1052 input, ok := in.Parameters.(*HttpPrefixHeadersInput) 1053 _ = input 1054 if !ok { 1055 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1056 } 1057 1058 opPath, opQuery := httpbinding.SplitURI("/HttpPrefixHeaders") 1059 request.URL.Path = opPath 1060 if len(request.URL.RawQuery) > 0 { 1061 request.URL.RawQuery = "&" + opQuery 1062 } else { 1063 request.URL.RawQuery = opQuery 1064 } 1065 1066 request.Method = "GET" 1067 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1068 if err != nil { 1069 return out, metadata, &smithy.SerializationError{Err: err} 1070 } 1071 1072 if err := awsRestxml_serializeOpHttpBindingsHttpPrefixHeadersInput(input, restEncoder); err != nil { 1073 return out, metadata, &smithy.SerializationError{Err: err} 1074 } 1075 1076 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1077 return out, metadata, &smithy.SerializationError{Err: err} 1078 } 1079 in.Request = request 1080 1081 return next.HandleSerialize(ctx, in) 1082} 1083func awsRestxml_serializeOpHttpBindingsHttpPrefixHeadersInput(v *HttpPrefixHeadersInput, encoder *httpbinding.Encoder) error { 1084 if v == nil { 1085 return fmt.Errorf("unsupported serialization of nil %T", v) 1086 } 1087 1088 if v.Foo != nil && len(*v.Foo) > 0 { 1089 locationName := "X-Foo" 1090 encoder.SetHeader(locationName).String(*v.Foo) 1091 } 1092 1093 if v.FooMap != nil { 1094 hv := encoder.Headers("X-Foo-") 1095 for mapKey, mapVal := range v.FooMap { 1096 if len(mapVal) > 0 { 1097 hv.SetHeader(http.CanonicalHeaderKey(mapKey)).String(mapVal) 1098 } 1099 } 1100 } 1101 1102 return nil 1103} 1104 1105type awsRestxml_serializeOpHttpRequestWithGreedyLabelInPath struct { 1106} 1107 1108func (*awsRestxml_serializeOpHttpRequestWithGreedyLabelInPath) ID() string { 1109 return "OperationSerializer" 1110} 1111 1112func (m *awsRestxml_serializeOpHttpRequestWithGreedyLabelInPath) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1113 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1114) { 1115 request, ok := in.Request.(*smithyhttp.Request) 1116 if !ok { 1117 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1118 } 1119 1120 input, ok := in.Parameters.(*HttpRequestWithGreedyLabelInPathInput) 1121 _ = input 1122 if !ok { 1123 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1124 } 1125 1126 opPath, opQuery := httpbinding.SplitURI("/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}") 1127 request.URL.Path = opPath 1128 if len(request.URL.RawQuery) > 0 { 1129 request.URL.RawQuery = "&" + opQuery 1130 } else { 1131 request.URL.RawQuery = opQuery 1132 } 1133 1134 request.Method = "GET" 1135 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1136 if err != nil { 1137 return out, metadata, &smithy.SerializationError{Err: err} 1138 } 1139 1140 if err := awsRestxml_serializeOpHttpBindingsHttpRequestWithGreedyLabelInPathInput(input, restEncoder); err != nil { 1141 return out, metadata, &smithy.SerializationError{Err: err} 1142 } 1143 1144 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1145 return out, metadata, &smithy.SerializationError{Err: err} 1146 } 1147 in.Request = request 1148 1149 return next.HandleSerialize(ctx, in) 1150} 1151func awsRestxml_serializeOpHttpBindingsHttpRequestWithGreedyLabelInPathInput(v *HttpRequestWithGreedyLabelInPathInput, encoder *httpbinding.Encoder) error { 1152 if v == nil { 1153 return fmt.Errorf("unsupported serialization of nil %T", v) 1154 } 1155 1156 if v.Baz == nil || len(*v.Baz) == 0 { 1157 return &smithy.SerializationError{Err: fmt.Errorf("input member baz must not be empty")} 1158 } 1159 if v.Baz != nil { 1160 if err := encoder.SetURI("baz").String(*v.Baz); err != nil { 1161 return err 1162 } 1163 } 1164 1165 if v.Foo == nil || len(*v.Foo) == 0 { 1166 return &smithy.SerializationError{Err: fmt.Errorf("input member foo must not be empty")} 1167 } 1168 if v.Foo != nil { 1169 if err := encoder.SetURI("foo").String(*v.Foo); err != nil { 1170 return err 1171 } 1172 } 1173 1174 return nil 1175} 1176 1177type awsRestxml_serializeOpHttpRequestWithLabels struct { 1178} 1179 1180func (*awsRestxml_serializeOpHttpRequestWithLabels) ID() string { 1181 return "OperationSerializer" 1182} 1183 1184func (m *awsRestxml_serializeOpHttpRequestWithLabels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1185 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1186) { 1187 request, ok := in.Request.(*smithyhttp.Request) 1188 if !ok { 1189 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1190 } 1191 1192 input, ok := in.Parameters.(*HttpRequestWithLabelsInput) 1193 _ = input 1194 if !ok { 1195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1196 } 1197 1198 opPath, opQuery := httpbinding.SplitURI("/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}") 1199 request.URL.Path = opPath 1200 if len(request.URL.RawQuery) > 0 { 1201 request.URL.RawQuery = "&" + opQuery 1202 } else { 1203 request.URL.RawQuery = opQuery 1204 } 1205 1206 request.Method = "GET" 1207 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1208 if err != nil { 1209 return out, metadata, &smithy.SerializationError{Err: err} 1210 } 1211 1212 if err := awsRestxml_serializeOpHttpBindingsHttpRequestWithLabelsInput(input, restEncoder); err != nil { 1213 return out, metadata, &smithy.SerializationError{Err: err} 1214 } 1215 1216 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1217 return out, metadata, &smithy.SerializationError{Err: err} 1218 } 1219 in.Request = request 1220 1221 return next.HandleSerialize(ctx, in) 1222} 1223func awsRestxml_serializeOpHttpBindingsHttpRequestWithLabelsInput(v *HttpRequestWithLabelsInput, encoder *httpbinding.Encoder) error { 1224 if v == nil { 1225 return fmt.Errorf("unsupported serialization of nil %T", v) 1226 } 1227 1228 if v.Boolean == nil { 1229 return &smithy.SerializationError{Err: fmt.Errorf("input member boolean must not be empty")} 1230 } 1231 if v.Boolean != nil { 1232 if err := encoder.SetURI("boolean").Boolean(*v.Boolean); err != nil { 1233 return err 1234 } 1235 } 1236 1237 if v.Double == nil { 1238 return &smithy.SerializationError{Err: fmt.Errorf("input member double must not be empty")} 1239 } 1240 if v.Double != nil { 1241 if err := encoder.SetURI("double").Double(*v.Double); err != nil { 1242 return err 1243 } 1244 } 1245 1246 if v.Float == nil { 1247 return &smithy.SerializationError{Err: fmt.Errorf("input member float must not be empty")} 1248 } 1249 if v.Float != nil { 1250 if err := encoder.SetURI("float").Float(*v.Float); err != nil { 1251 return err 1252 } 1253 } 1254 1255 if v.Integer == nil { 1256 return &smithy.SerializationError{Err: fmt.Errorf("input member integer must not be empty")} 1257 } 1258 if v.Integer != nil { 1259 if err := encoder.SetURI("integer").Integer(*v.Integer); err != nil { 1260 return err 1261 } 1262 } 1263 1264 if v.Long == nil { 1265 return &smithy.SerializationError{Err: fmt.Errorf("input member long must not be empty")} 1266 } 1267 if v.Long != nil { 1268 if err := encoder.SetURI("long").Long(*v.Long); err != nil { 1269 return err 1270 } 1271 } 1272 1273 if v.Short == nil { 1274 return &smithy.SerializationError{Err: fmt.Errorf("input member short must not be empty")} 1275 } 1276 if v.Short != nil { 1277 if err := encoder.SetURI("short").Short(*v.Short); err != nil { 1278 return err 1279 } 1280 } 1281 1282 if v.String_ == nil || len(*v.String_) == 0 { 1283 return &smithy.SerializationError{Err: fmt.Errorf("input member string must not be empty")} 1284 } 1285 if v.String_ != nil { 1286 if err := encoder.SetURI("string").String(*v.String_); err != nil { 1287 return err 1288 } 1289 } 1290 1291 if v.Timestamp == nil { 1292 return &smithy.SerializationError{Err: fmt.Errorf("input member timestamp must not be empty")} 1293 } 1294 if v.Timestamp != nil { 1295 if err := encoder.SetURI("timestamp").String(smithytime.FormatDateTime(*v.Timestamp)); err != nil { 1296 return err 1297 } 1298 } 1299 1300 return nil 1301} 1302 1303type awsRestxml_serializeOpHttpRequestWithLabelsAndTimestampFormat struct { 1304} 1305 1306func (*awsRestxml_serializeOpHttpRequestWithLabelsAndTimestampFormat) ID() string { 1307 return "OperationSerializer" 1308} 1309 1310func (m *awsRestxml_serializeOpHttpRequestWithLabelsAndTimestampFormat) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1311 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1312) { 1313 request, ok := in.Request.(*smithyhttp.Request) 1314 if !ok { 1315 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1316 } 1317 1318 input, ok := in.Parameters.(*HttpRequestWithLabelsAndTimestampFormatInput) 1319 _ = input 1320 if !ok { 1321 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1322 } 1323 1324 opPath, opQuery := httpbinding.SplitURI("/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}") 1325 request.URL.Path = opPath 1326 if len(request.URL.RawQuery) > 0 { 1327 request.URL.RawQuery = "&" + opQuery 1328 } else { 1329 request.URL.RawQuery = opQuery 1330 } 1331 1332 request.Method = "GET" 1333 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1334 if err != nil { 1335 return out, metadata, &smithy.SerializationError{Err: err} 1336 } 1337 1338 if err := awsRestxml_serializeOpHttpBindingsHttpRequestWithLabelsAndTimestampFormatInput(input, restEncoder); err != nil { 1339 return out, metadata, &smithy.SerializationError{Err: err} 1340 } 1341 1342 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1343 return out, metadata, &smithy.SerializationError{Err: err} 1344 } 1345 in.Request = request 1346 1347 return next.HandleSerialize(ctx, in) 1348} 1349func awsRestxml_serializeOpHttpBindingsHttpRequestWithLabelsAndTimestampFormatInput(v *HttpRequestWithLabelsAndTimestampFormatInput, encoder *httpbinding.Encoder) error { 1350 if v == nil { 1351 return fmt.Errorf("unsupported serialization of nil %T", v) 1352 } 1353 1354 if v.DefaultFormat == nil { 1355 return &smithy.SerializationError{Err: fmt.Errorf("input member defaultFormat must not be empty")} 1356 } 1357 if v.DefaultFormat != nil { 1358 if err := encoder.SetURI("defaultFormat").String(smithytime.FormatDateTime(*v.DefaultFormat)); err != nil { 1359 return err 1360 } 1361 } 1362 1363 if v.MemberDateTime == nil { 1364 return &smithy.SerializationError{Err: fmt.Errorf("input member memberDateTime must not be empty")} 1365 } 1366 if v.MemberDateTime != nil { 1367 if err := encoder.SetURI("memberDateTime").String(smithytime.FormatDateTime(*v.MemberDateTime)); err != nil { 1368 return err 1369 } 1370 } 1371 1372 if v.MemberEpochSeconds == nil { 1373 return &smithy.SerializationError{Err: fmt.Errorf("input member memberEpochSeconds must not be empty")} 1374 } 1375 if v.MemberEpochSeconds != nil { 1376 if err := encoder.SetURI("memberEpochSeconds").Double(smithytime.FormatEpochSeconds(*v.MemberEpochSeconds)); err != nil { 1377 return err 1378 } 1379 } 1380 1381 if v.MemberHttpDate == nil { 1382 return &smithy.SerializationError{Err: fmt.Errorf("input member memberHttpDate must not be empty")} 1383 } 1384 if v.MemberHttpDate != nil { 1385 if err := encoder.SetURI("memberHttpDate").String(smithytime.FormatHTTPDate(*v.MemberHttpDate)); err != nil { 1386 return err 1387 } 1388 } 1389 1390 if v.TargetDateTime == nil { 1391 return &smithy.SerializationError{Err: fmt.Errorf("input member targetDateTime must not be empty")} 1392 } 1393 if v.TargetDateTime != nil { 1394 if err := encoder.SetURI("targetDateTime").String(smithytime.FormatDateTime(*v.TargetDateTime)); err != nil { 1395 return err 1396 } 1397 } 1398 1399 if v.TargetEpochSeconds == nil { 1400 return &smithy.SerializationError{Err: fmt.Errorf("input member targetEpochSeconds must not be empty")} 1401 } 1402 if v.TargetEpochSeconds != nil { 1403 if err := encoder.SetURI("targetEpochSeconds").Double(smithytime.FormatEpochSeconds(*v.TargetEpochSeconds)); err != nil { 1404 return err 1405 } 1406 } 1407 1408 if v.TargetHttpDate == nil { 1409 return &smithy.SerializationError{Err: fmt.Errorf("input member targetHttpDate must not be empty")} 1410 } 1411 if v.TargetHttpDate != nil { 1412 if err := encoder.SetURI("targetHttpDate").String(smithytime.FormatHTTPDate(*v.TargetHttpDate)); err != nil { 1413 return err 1414 } 1415 } 1416 1417 return nil 1418} 1419 1420type awsRestxml_serializeOpHttpResponseCode struct { 1421} 1422 1423func (*awsRestxml_serializeOpHttpResponseCode) ID() string { 1424 return "OperationSerializer" 1425} 1426 1427func (m *awsRestxml_serializeOpHttpResponseCode) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1428 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1429) { 1430 request, ok := in.Request.(*smithyhttp.Request) 1431 if !ok { 1432 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1433 } 1434 1435 input, ok := in.Parameters.(*HttpResponseCodeInput) 1436 _ = input 1437 if !ok { 1438 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1439 } 1440 1441 opPath, opQuery := httpbinding.SplitURI("/HttpResponseCode") 1442 request.URL.Path = opPath 1443 if len(request.URL.RawQuery) > 0 { 1444 request.URL.RawQuery = "&" + opQuery 1445 } else { 1446 request.URL.RawQuery = opQuery 1447 } 1448 1449 request.Method = "PUT" 1450 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1451 if err != nil { 1452 return out, metadata, &smithy.SerializationError{Err: err} 1453 } 1454 1455 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1456 return out, metadata, &smithy.SerializationError{Err: err} 1457 } 1458 in.Request = request 1459 1460 return next.HandleSerialize(ctx, in) 1461} 1462func awsRestxml_serializeOpHttpBindingsHttpResponseCodeInput(v *HttpResponseCodeInput, encoder *httpbinding.Encoder) error { 1463 if v == nil { 1464 return fmt.Errorf("unsupported serialization of nil %T", v) 1465 } 1466 1467 return nil 1468} 1469 1470type awsRestxml_serializeOpIgnoreQueryParamsInResponse struct { 1471} 1472 1473func (*awsRestxml_serializeOpIgnoreQueryParamsInResponse) ID() string { 1474 return "OperationSerializer" 1475} 1476 1477func (m *awsRestxml_serializeOpIgnoreQueryParamsInResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1478 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1479) { 1480 request, ok := in.Request.(*smithyhttp.Request) 1481 if !ok { 1482 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1483 } 1484 1485 input, ok := in.Parameters.(*IgnoreQueryParamsInResponseInput) 1486 _ = input 1487 if !ok { 1488 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1489 } 1490 1491 opPath, opQuery := httpbinding.SplitURI("/IgnoreQueryParamsInResponse") 1492 request.URL.Path = opPath 1493 if len(request.URL.RawQuery) > 0 { 1494 request.URL.RawQuery = "&" + opQuery 1495 } else { 1496 request.URL.RawQuery = opQuery 1497 } 1498 1499 request.Method = "GET" 1500 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1501 if err != nil { 1502 return out, metadata, &smithy.SerializationError{Err: err} 1503 } 1504 1505 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1506 return out, metadata, &smithy.SerializationError{Err: err} 1507 } 1508 in.Request = request 1509 1510 return next.HandleSerialize(ctx, in) 1511} 1512func awsRestxml_serializeOpHttpBindingsIgnoreQueryParamsInResponseInput(v *IgnoreQueryParamsInResponseInput, encoder *httpbinding.Encoder) error { 1513 if v == nil { 1514 return fmt.Errorf("unsupported serialization of nil %T", v) 1515 } 1516 1517 return nil 1518} 1519 1520type awsRestxml_serializeOpInputAndOutputWithHeaders struct { 1521} 1522 1523func (*awsRestxml_serializeOpInputAndOutputWithHeaders) ID() string { 1524 return "OperationSerializer" 1525} 1526 1527func (m *awsRestxml_serializeOpInputAndOutputWithHeaders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1528 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1529) { 1530 request, ok := in.Request.(*smithyhttp.Request) 1531 if !ok { 1532 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1533 } 1534 1535 input, ok := in.Parameters.(*InputAndOutputWithHeadersInput) 1536 _ = input 1537 if !ok { 1538 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1539 } 1540 1541 opPath, opQuery := httpbinding.SplitURI("/InputAndOutputWithHeaders") 1542 request.URL.Path = opPath 1543 if len(request.URL.RawQuery) > 0 { 1544 request.URL.RawQuery = "&" + opQuery 1545 } else { 1546 request.URL.RawQuery = opQuery 1547 } 1548 1549 request.Method = "POST" 1550 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1551 if err != nil { 1552 return out, metadata, &smithy.SerializationError{Err: err} 1553 } 1554 1555 if err := awsRestxml_serializeOpHttpBindingsInputAndOutputWithHeadersInput(input, restEncoder); err != nil { 1556 return out, metadata, &smithy.SerializationError{Err: err} 1557 } 1558 1559 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1560 return out, metadata, &smithy.SerializationError{Err: err} 1561 } 1562 in.Request = request 1563 1564 return next.HandleSerialize(ctx, in) 1565} 1566func awsRestxml_serializeOpHttpBindingsInputAndOutputWithHeadersInput(v *InputAndOutputWithHeadersInput, encoder *httpbinding.Encoder) error { 1567 if v == nil { 1568 return fmt.Errorf("unsupported serialization of nil %T", v) 1569 } 1570 1571 if v.HeaderBooleanList != nil { 1572 locationName := "X-Booleanlist" 1573 for i := range v.HeaderBooleanList { 1574 { 1575 encoder.AddHeader(locationName).Boolean(v.HeaderBooleanList[i]) 1576 } 1577 } 1578 } 1579 1580 if v.HeaderByte != nil { 1581 locationName := "X-Byte" 1582 encoder.SetHeader(locationName).Byte(*v.HeaderByte) 1583 } 1584 1585 if v.HeaderDouble != nil { 1586 locationName := "X-Double" 1587 encoder.SetHeader(locationName).Double(*v.HeaderDouble) 1588 } 1589 1590 if len(v.HeaderEnum) > 0 { 1591 locationName := "X-Enum" 1592 encoder.SetHeader(locationName).String(string(v.HeaderEnum)) 1593 } 1594 1595 if v.HeaderEnumList != nil { 1596 locationName := "X-Enumlist" 1597 for i := range v.HeaderEnumList { 1598 if len(v.HeaderEnumList[i]) > 0 { 1599 encoder.AddHeader(locationName).String(string(v.HeaderEnumList[i])) 1600 } 1601 } 1602 } 1603 1604 if v.HeaderFalseBool != nil { 1605 locationName := "X-Boolean2" 1606 encoder.SetHeader(locationName).Boolean(*v.HeaderFalseBool) 1607 } 1608 1609 if v.HeaderFloat != nil { 1610 locationName := "X-Float" 1611 encoder.SetHeader(locationName).Float(*v.HeaderFloat) 1612 } 1613 1614 if v.HeaderInteger != nil { 1615 locationName := "X-Integer" 1616 encoder.SetHeader(locationName).Integer(*v.HeaderInteger) 1617 } 1618 1619 if v.HeaderIntegerList != nil { 1620 locationName := "X-Integerlist" 1621 for i := range v.HeaderIntegerList { 1622 { 1623 encoder.AddHeader(locationName).Integer(v.HeaderIntegerList[i]) 1624 } 1625 } 1626 } 1627 1628 if v.HeaderLong != nil { 1629 locationName := "X-Long" 1630 encoder.SetHeader(locationName).Long(*v.HeaderLong) 1631 } 1632 1633 if v.HeaderShort != nil { 1634 locationName := "X-Short" 1635 encoder.SetHeader(locationName).Short(*v.HeaderShort) 1636 } 1637 1638 if v.HeaderString != nil && len(*v.HeaderString) > 0 { 1639 locationName := "X-String" 1640 encoder.SetHeader(locationName).String(*v.HeaderString) 1641 } 1642 1643 if v.HeaderStringList != nil { 1644 locationName := "X-Stringlist" 1645 for i := range v.HeaderStringList { 1646 if len(v.HeaderStringList[i]) > 0 { 1647 encoder.AddHeader(locationName).String(v.HeaderStringList[i]) 1648 } 1649 } 1650 } 1651 1652 if v.HeaderStringSet != nil { 1653 locationName := "X-Stringset" 1654 for i := range v.HeaderStringSet { 1655 if len(v.HeaderStringSet[i]) > 0 { 1656 encoder.AddHeader(locationName).String(v.HeaderStringSet[i]) 1657 } 1658 } 1659 } 1660 1661 if v.HeaderTimestampList != nil { 1662 locationName := "X-Timestamplist" 1663 for i := range v.HeaderTimestampList { 1664 { 1665 encoder.AddHeader(locationName).String(smithytime.FormatHTTPDate(v.HeaderTimestampList[i])) 1666 } 1667 } 1668 } 1669 1670 if v.HeaderTrueBool != nil { 1671 locationName := "X-Boolean1" 1672 encoder.SetHeader(locationName).Boolean(*v.HeaderTrueBool) 1673 } 1674 1675 return nil 1676} 1677 1678type awsRestxml_serializeOpNoInputAndNoOutput struct { 1679} 1680 1681func (*awsRestxml_serializeOpNoInputAndNoOutput) ID() string { 1682 return "OperationSerializer" 1683} 1684 1685func (m *awsRestxml_serializeOpNoInputAndNoOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1686 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1687) { 1688 request, ok := in.Request.(*smithyhttp.Request) 1689 if !ok { 1690 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1691 } 1692 1693 input, ok := in.Parameters.(*NoInputAndNoOutputInput) 1694 _ = input 1695 if !ok { 1696 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1697 } 1698 1699 opPath, opQuery := httpbinding.SplitURI("/NoInputAndNoOutput") 1700 request.URL.Path = opPath 1701 if len(request.URL.RawQuery) > 0 { 1702 request.URL.RawQuery = "&" + opQuery 1703 } else { 1704 request.URL.RawQuery = opQuery 1705 } 1706 1707 request.Method = "POST" 1708 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1709 if err != nil { 1710 return out, metadata, &smithy.SerializationError{Err: err} 1711 } 1712 1713 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1714 return out, metadata, &smithy.SerializationError{Err: err} 1715 } 1716 in.Request = request 1717 1718 return next.HandleSerialize(ctx, in) 1719} 1720func awsRestxml_serializeOpHttpBindingsNoInputAndNoOutputInput(v *NoInputAndNoOutputInput, encoder *httpbinding.Encoder) error { 1721 if v == nil { 1722 return fmt.Errorf("unsupported serialization of nil %T", v) 1723 } 1724 1725 return nil 1726} 1727 1728type awsRestxml_serializeOpNoInputAndOutput struct { 1729} 1730 1731func (*awsRestxml_serializeOpNoInputAndOutput) ID() string { 1732 return "OperationSerializer" 1733} 1734 1735func (m *awsRestxml_serializeOpNoInputAndOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1736 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1737) { 1738 request, ok := in.Request.(*smithyhttp.Request) 1739 if !ok { 1740 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1741 } 1742 1743 input, ok := in.Parameters.(*NoInputAndOutputInput) 1744 _ = input 1745 if !ok { 1746 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1747 } 1748 1749 opPath, opQuery := httpbinding.SplitURI("/NoInputAndOutputOutput") 1750 request.URL.Path = opPath 1751 if len(request.URL.RawQuery) > 0 { 1752 request.URL.RawQuery = "&" + opQuery 1753 } else { 1754 request.URL.RawQuery = opQuery 1755 } 1756 1757 request.Method = "POST" 1758 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1759 if err != nil { 1760 return out, metadata, &smithy.SerializationError{Err: err} 1761 } 1762 1763 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1764 return out, metadata, &smithy.SerializationError{Err: err} 1765 } 1766 in.Request = request 1767 1768 return next.HandleSerialize(ctx, in) 1769} 1770func awsRestxml_serializeOpHttpBindingsNoInputAndOutputInput(v *NoInputAndOutputInput, encoder *httpbinding.Encoder) error { 1771 if v == nil { 1772 return fmt.Errorf("unsupported serialization of nil %T", v) 1773 } 1774 1775 return nil 1776} 1777 1778type awsRestxml_serializeOpNullAndEmptyHeadersClient struct { 1779} 1780 1781func (*awsRestxml_serializeOpNullAndEmptyHeadersClient) ID() string { 1782 return "OperationSerializer" 1783} 1784 1785func (m *awsRestxml_serializeOpNullAndEmptyHeadersClient) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1786 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1787) { 1788 request, ok := in.Request.(*smithyhttp.Request) 1789 if !ok { 1790 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1791 } 1792 1793 input, ok := in.Parameters.(*NullAndEmptyHeadersClientInput) 1794 _ = input 1795 if !ok { 1796 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1797 } 1798 1799 opPath, opQuery := httpbinding.SplitURI("/NullAndEmptyHeadersClient") 1800 request.URL.Path = opPath 1801 if len(request.URL.RawQuery) > 0 { 1802 request.URL.RawQuery = "&" + opQuery 1803 } else { 1804 request.URL.RawQuery = opQuery 1805 } 1806 1807 request.Method = "GET" 1808 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1809 if err != nil { 1810 return out, metadata, &smithy.SerializationError{Err: err} 1811 } 1812 1813 if err := awsRestxml_serializeOpHttpBindingsNullAndEmptyHeadersClientInput(input, restEncoder); err != nil { 1814 return out, metadata, &smithy.SerializationError{Err: err} 1815 } 1816 1817 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1818 return out, metadata, &smithy.SerializationError{Err: err} 1819 } 1820 in.Request = request 1821 1822 return next.HandleSerialize(ctx, in) 1823} 1824func awsRestxml_serializeOpHttpBindingsNullAndEmptyHeadersClientInput(v *NullAndEmptyHeadersClientInput, encoder *httpbinding.Encoder) error { 1825 if v == nil { 1826 return fmt.Errorf("unsupported serialization of nil %T", v) 1827 } 1828 1829 if v.A != nil && len(*v.A) > 0 { 1830 locationName := "X-A" 1831 encoder.SetHeader(locationName).String(*v.A) 1832 } 1833 1834 if v.B != nil && len(*v.B) > 0 { 1835 locationName := "X-B" 1836 encoder.SetHeader(locationName).String(*v.B) 1837 } 1838 1839 if v.C != nil { 1840 locationName := "X-C" 1841 for i := range v.C { 1842 if len(v.C[i]) > 0 { 1843 encoder.AddHeader(locationName).String(v.C[i]) 1844 } 1845 } 1846 } 1847 1848 return nil 1849} 1850 1851type awsRestxml_serializeOpNullAndEmptyHeadersServer struct { 1852} 1853 1854func (*awsRestxml_serializeOpNullAndEmptyHeadersServer) ID() string { 1855 return "OperationSerializer" 1856} 1857 1858func (m *awsRestxml_serializeOpNullAndEmptyHeadersServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1859 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1860) { 1861 request, ok := in.Request.(*smithyhttp.Request) 1862 if !ok { 1863 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1864 } 1865 1866 input, ok := in.Parameters.(*NullAndEmptyHeadersServerInput) 1867 _ = input 1868 if !ok { 1869 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1870 } 1871 1872 opPath, opQuery := httpbinding.SplitURI("/NullAndEmptyHeadersServer") 1873 request.URL.Path = opPath 1874 if len(request.URL.RawQuery) > 0 { 1875 request.URL.RawQuery = "&" + opQuery 1876 } else { 1877 request.URL.RawQuery = opQuery 1878 } 1879 1880 request.Method = "GET" 1881 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1882 if err != nil { 1883 return out, metadata, &smithy.SerializationError{Err: err} 1884 } 1885 1886 if err := awsRestxml_serializeOpHttpBindingsNullAndEmptyHeadersServerInput(input, restEncoder); err != nil { 1887 return out, metadata, &smithy.SerializationError{Err: err} 1888 } 1889 1890 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1891 return out, metadata, &smithy.SerializationError{Err: err} 1892 } 1893 in.Request = request 1894 1895 return next.HandleSerialize(ctx, in) 1896} 1897func awsRestxml_serializeOpHttpBindingsNullAndEmptyHeadersServerInput(v *NullAndEmptyHeadersServerInput, encoder *httpbinding.Encoder) error { 1898 if v == nil { 1899 return fmt.Errorf("unsupported serialization of nil %T", v) 1900 } 1901 1902 if v.A != nil && len(*v.A) > 0 { 1903 locationName := "X-A" 1904 encoder.SetHeader(locationName).String(*v.A) 1905 } 1906 1907 if v.B != nil && len(*v.B) > 0 { 1908 locationName := "X-B" 1909 encoder.SetHeader(locationName).String(*v.B) 1910 } 1911 1912 if v.C != nil { 1913 locationName := "X-C" 1914 for i := range v.C { 1915 if len(v.C[i]) > 0 { 1916 encoder.AddHeader(locationName).String(v.C[i]) 1917 } 1918 } 1919 } 1920 1921 return nil 1922} 1923 1924type awsRestxml_serializeOpOmitsNullSerializesEmptyString struct { 1925} 1926 1927func (*awsRestxml_serializeOpOmitsNullSerializesEmptyString) ID() string { 1928 return "OperationSerializer" 1929} 1930 1931func (m *awsRestxml_serializeOpOmitsNullSerializesEmptyString) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1932 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1933) { 1934 request, ok := in.Request.(*smithyhttp.Request) 1935 if !ok { 1936 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1937 } 1938 1939 input, ok := in.Parameters.(*OmitsNullSerializesEmptyStringInput) 1940 _ = input 1941 if !ok { 1942 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1943 } 1944 1945 opPath, opQuery := httpbinding.SplitURI("/OmitsNullSerializesEmptyString") 1946 request.URL.Path = opPath 1947 if len(request.URL.RawQuery) > 0 { 1948 request.URL.RawQuery = "&" + opQuery 1949 } else { 1950 request.URL.RawQuery = opQuery 1951 } 1952 1953 request.Method = "GET" 1954 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1955 if err != nil { 1956 return out, metadata, &smithy.SerializationError{Err: err} 1957 } 1958 1959 if err := awsRestxml_serializeOpHttpBindingsOmitsNullSerializesEmptyStringInput(input, restEncoder); err != nil { 1960 return out, metadata, &smithy.SerializationError{Err: err} 1961 } 1962 1963 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1964 return out, metadata, &smithy.SerializationError{Err: err} 1965 } 1966 in.Request = request 1967 1968 return next.HandleSerialize(ctx, in) 1969} 1970func awsRestxml_serializeOpHttpBindingsOmitsNullSerializesEmptyStringInput(v *OmitsNullSerializesEmptyStringInput, encoder *httpbinding.Encoder) error { 1971 if v == nil { 1972 return fmt.Errorf("unsupported serialization of nil %T", v) 1973 } 1974 1975 if v.EmptyString != nil { 1976 encoder.SetQuery("Empty").String(*v.EmptyString) 1977 } 1978 1979 if v.NullValue != nil { 1980 encoder.SetQuery("Null").String(*v.NullValue) 1981 } 1982 1983 return nil 1984} 1985 1986type awsRestxml_serializeOpQueryIdempotencyTokenAutoFill struct { 1987} 1988 1989func (*awsRestxml_serializeOpQueryIdempotencyTokenAutoFill) ID() string { 1990 return "OperationSerializer" 1991} 1992 1993func (m *awsRestxml_serializeOpQueryIdempotencyTokenAutoFill) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1994 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1995) { 1996 request, ok := in.Request.(*smithyhttp.Request) 1997 if !ok { 1998 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1999 } 2000 2001 input, ok := in.Parameters.(*QueryIdempotencyTokenAutoFillInput) 2002 _ = input 2003 if !ok { 2004 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2005 } 2006 2007 opPath, opQuery := httpbinding.SplitURI("/QueryIdempotencyTokenAutoFill") 2008 request.URL.Path = opPath 2009 if len(request.URL.RawQuery) > 0 { 2010 request.URL.RawQuery = "&" + opQuery 2011 } else { 2012 request.URL.RawQuery = opQuery 2013 } 2014 2015 request.Method = "POST" 2016 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2017 if err != nil { 2018 return out, metadata, &smithy.SerializationError{Err: err} 2019 } 2020 2021 if err := awsRestxml_serializeOpHttpBindingsQueryIdempotencyTokenAutoFillInput(input, restEncoder); err != nil { 2022 return out, metadata, &smithy.SerializationError{Err: err} 2023 } 2024 2025 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2026 return out, metadata, &smithy.SerializationError{Err: err} 2027 } 2028 in.Request = request 2029 2030 return next.HandleSerialize(ctx, in) 2031} 2032func awsRestxml_serializeOpHttpBindingsQueryIdempotencyTokenAutoFillInput(v *QueryIdempotencyTokenAutoFillInput, encoder *httpbinding.Encoder) error { 2033 if v == nil { 2034 return fmt.Errorf("unsupported serialization of nil %T", v) 2035 } 2036 2037 if v.Token != nil { 2038 encoder.SetQuery("token").String(*v.Token) 2039 } 2040 2041 return nil 2042} 2043 2044type awsRestxml_serializeOpRecursiveShapes struct { 2045} 2046 2047func (*awsRestxml_serializeOpRecursiveShapes) ID() string { 2048 return "OperationSerializer" 2049} 2050 2051func (m *awsRestxml_serializeOpRecursiveShapes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2052 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2053) { 2054 request, ok := in.Request.(*smithyhttp.Request) 2055 if !ok { 2056 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2057 } 2058 2059 input, ok := in.Parameters.(*RecursiveShapesInput) 2060 _ = input 2061 if !ok { 2062 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2063 } 2064 2065 opPath, opQuery := httpbinding.SplitURI("/RecursiveShapes") 2066 request.URL.Path = opPath 2067 if len(request.URL.RawQuery) > 0 { 2068 request.URL.RawQuery = "&" + opQuery 2069 } else { 2070 request.URL.RawQuery = opQuery 2071 } 2072 2073 request.Method = "PUT" 2074 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2075 if err != nil { 2076 return out, metadata, &smithy.SerializationError{Err: err} 2077 } 2078 2079 restEncoder.SetHeader("Content-Type").String("application/xml") 2080 2081 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2082 rootAttr := []smithyxml.Attr{} 2083 root := smithyxml.StartElement{ 2084 Name: smithyxml.Name{ 2085 Local: "RecursiveShapesInputOutput", 2086 }, 2087 Attr: rootAttr, 2088 } 2089 if err := awsRestxml_serializeOpDocumentRecursiveShapesInput(input, xmlEncoder.RootElement(root)); err != nil { 2090 return out, metadata, &smithy.SerializationError{Err: err} 2091 } 2092 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2093 return out, metadata, &smithy.SerializationError{Err: err} 2094 } 2095 2096 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2097 return out, metadata, &smithy.SerializationError{Err: err} 2098 } 2099 in.Request = request 2100 2101 return next.HandleSerialize(ctx, in) 2102} 2103func awsRestxml_serializeOpHttpBindingsRecursiveShapesInput(v *RecursiveShapesInput, encoder *httpbinding.Encoder) error { 2104 if v == nil { 2105 return fmt.Errorf("unsupported serialization of nil %T", v) 2106 } 2107 2108 return nil 2109} 2110 2111func awsRestxml_serializeOpDocumentRecursiveShapesInput(v *RecursiveShapesInput, value smithyxml.Value) error { 2112 defer value.Close() 2113 if v.Nested != nil { 2114 rootAttr := []smithyxml.Attr{} 2115 root := smithyxml.StartElement{ 2116 Name: smithyxml.Name{ 2117 Local: "nested", 2118 }, 2119 Attr: rootAttr, 2120 } 2121 el := value.MemberElement(root) 2122 if err := awsRestxml_serializeDocumentRecursiveShapesInputOutputNested1(v.Nested, el); err != nil { 2123 return err 2124 } 2125 } 2126 return nil 2127} 2128 2129type awsRestxml_serializeOpSimpleScalarProperties struct { 2130} 2131 2132func (*awsRestxml_serializeOpSimpleScalarProperties) ID() string { 2133 return "OperationSerializer" 2134} 2135 2136func (m *awsRestxml_serializeOpSimpleScalarProperties) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2137 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2138) { 2139 request, ok := in.Request.(*smithyhttp.Request) 2140 if !ok { 2141 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2142 } 2143 2144 input, ok := in.Parameters.(*SimpleScalarPropertiesInput) 2145 _ = input 2146 if !ok { 2147 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2148 } 2149 2150 opPath, opQuery := httpbinding.SplitURI("/SimpleScalarProperties") 2151 request.URL.Path = opPath 2152 if len(request.URL.RawQuery) > 0 { 2153 request.URL.RawQuery = "&" + opQuery 2154 } else { 2155 request.URL.RawQuery = opQuery 2156 } 2157 2158 request.Method = "PUT" 2159 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2160 if err != nil { 2161 return out, metadata, &smithy.SerializationError{Err: err} 2162 } 2163 2164 if err := awsRestxml_serializeOpHttpBindingsSimpleScalarPropertiesInput(input, restEncoder); err != nil { 2165 return out, metadata, &smithy.SerializationError{Err: err} 2166 } 2167 2168 restEncoder.SetHeader("Content-Type").String("application/xml") 2169 2170 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2171 rootAttr := []smithyxml.Attr{} 2172 root := smithyxml.StartElement{ 2173 Name: smithyxml.Name{ 2174 Local: "SimpleScalarPropertiesInputOutput", 2175 }, 2176 Attr: rootAttr, 2177 } 2178 if err := awsRestxml_serializeOpDocumentSimpleScalarPropertiesInput(input, xmlEncoder.RootElement(root)); err != nil { 2179 return out, metadata, &smithy.SerializationError{Err: err} 2180 } 2181 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2182 return out, metadata, &smithy.SerializationError{Err: err} 2183 } 2184 2185 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2186 return out, metadata, &smithy.SerializationError{Err: err} 2187 } 2188 in.Request = request 2189 2190 return next.HandleSerialize(ctx, in) 2191} 2192func awsRestxml_serializeOpHttpBindingsSimpleScalarPropertiesInput(v *SimpleScalarPropertiesInput, encoder *httpbinding.Encoder) error { 2193 if v == nil { 2194 return fmt.Errorf("unsupported serialization of nil %T", v) 2195 } 2196 2197 if v.Foo != nil && len(*v.Foo) > 0 { 2198 locationName := "X-Foo" 2199 encoder.SetHeader(locationName).String(*v.Foo) 2200 } 2201 2202 return nil 2203} 2204 2205func awsRestxml_serializeOpDocumentSimpleScalarPropertiesInput(v *SimpleScalarPropertiesInput, value smithyxml.Value) error { 2206 defer value.Close() 2207 if v.ByteValue != nil { 2208 rootAttr := []smithyxml.Attr{} 2209 root := smithyxml.StartElement{ 2210 Name: smithyxml.Name{ 2211 Local: "byteValue", 2212 }, 2213 Attr: rootAttr, 2214 } 2215 el := value.MemberElement(root) 2216 el.Byte(*v.ByteValue) 2217 } 2218 if v.DoubleValue != nil { 2219 rootAttr := []smithyxml.Attr{} 2220 root := smithyxml.StartElement{ 2221 Name: smithyxml.Name{ 2222 Local: "DoubleDribble", 2223 }, 2224 Attr: rootAttr, 2225 } 2226 el := value.MemberElement(root) 2227 el.Double(*v.DoubleValue) 2228 } 2229 if v.FalseBooleanValue != nil { 2230 rootAttr := []smithyxml.Attr{} 2231 root := smithyxml.StartElement{ 2232 Name: smithyxml.Name{ 2233 Local: "falseBooleanValue", 2234 }, 2235 Attr: rootAttr, 2236 } 2237 el := value.MemberElement(root) 2238 el.Boolean(*v.FalseBooleanValue) 2239 } 2240 if v.FloatValue != nil { 2241 rootAttr := []smithyxml.Attr{} 2242 root := smithyxml.StartElement{ 2243 Name: smithyxml.Name{ 2244 Local: "floatValue", 2245 }, 2246 Attr: rootAttr, 2247 } 2248 el := value.MemberElement(root) 2249 el.Float(*v.FloatValue) 2250 } 2251 if v.IntegerValue != nil { 2252 rootAttr := []smithyxml.Attr{} 2253 root := smithyxml.StartElement{ 2254 Name: smithyxml.Name{ 2255 Local: "integerValue", 2256 }, 2257 Attr: rootAttr, 2258 } 2259 el := value.MemberElement(root) 2260 el.Integer(*v.IntegerValue) 2261 } 2262 if v.LongValue != nil { 2263 rootAttr := []smithyxml.Attr{} 2264 root := smithyxml.StartElement{ 2265 Name: smithyxml.Name{ 2266 Local: "longValue", 2267 }, 2268 Attr: rootAttr, 2269 } 2270 el := value.MemberElement(root) 2271 el.Long(*v.LongValue) 2272 } 2273 if v.ShortValue != nil { 2274 rootAttr := []smithyxml.Attr{} 2275 root := smithyxml.StartElement{ 2276 Name: smithyxml.Name{ 2277 Local: "shortValue", 2278 }, 2279 Attr: rootAttr, 2280 } 2281 el := value.MemberElement(root) 2282 el.Short(*v.ShortValue) 2283 } 2284 if v.StringValue != nil { 2285 rootAttr := []smithyxml.Attr{} 2286 root := smithyxml.StartElement{ 2287 Name: smithyxml.Name{ 2288 Local: "stringValue", 2289 }, 2290 Attr: rootAttr, 2291 } 2292 el := value.MemberElement(root) 2293 el.String(*v.StringValue) 2294 } 2295 if v.TrueBooleanValue != nil { 2296 rootAttr := []smithyxml.Attr{} 2297 root := smithyxml.StartElement{ 2298 Name: smithyxml.Name{ 2299 Local: "trueBooleanValue", 2300 }, 2301 Attr: rootAttr, 2302 } 2303 el := value.MemberElement(root) 2304 el.Boolean(*v.TrueBooleanValue) 2305 } 2306 return nil 2307} 2308 2309type awsRestxml_serializeOpTimestampFormatHeaders struct { 2310} 2311 2312func (*awsRestxml_serializeOpTimestampFormatHeaders) ID() string { 2313 return "OperationSerializer" 2314} 2315 2316func (m *awsRestxml_serializeOpTimestampFormatHeaders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2317 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2318) { 2319 request, ok := in.Request.(*smithyhttp.Request) 2320 if !ok { 2321 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2322 } 2323 2324 input, ok := in.Parameters.(*TimestampFormatHeadersInput) 2325 _ = input 2326 if !ok { 2327 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2328 } 2329 2330 opPath, opQuery := httpbinding.SplitURI("/TimestampFormatHeaders") 2331 request.URL.Path = opPath 2332 if len(request.URL.RawQuery) > 0 { 2333 request.URL.RawQuery = "&" + opQuery 2334 } else { 2335 request.URL.RawQuery = opQuery 2336 } 2337 2338 request.Method = "POST" 2339 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2340 if err != nil { 2341 return out, metadata, &smithy.SerializationError{Err: err} 2342 } 2343 2344 if err := awsRestxml_serializeOpHttpBindingsTimestampFormatHeadersInput(input, restEncoder); err != nil { 2345 return out, metadata, &smithy.SerializationError{Err: err} 2346 } 2347 2348 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2349 return out, metadata, &smithy.SerializationError{Err: err} 2350 } 2351 in.Request = request 2352 2353 return next.HandleSerialize(ctx, in) 2354} 2355func awsRestxml_serializeOpHttpBindingsTimestampFormatHeadersInput(v *TimestampFormatHeadersInput, encoder *httpbinding.Encoder) error { 2356 if v == nil { 2357 return fmt.Errorf("unsupported serialization of nil %T", v) 2358 } 2359 2360 if v.DefaultFormat != nil { 2361 locationName := "X-Defaultformat" 2362 encoder.SetHeader(locationName).String(smithytime.FormatHTTPDate(*v.DefaultFormat)) 2363 } 2364 2365 if v.MemberDateTime != nil { 2366 locationName := "X-Memberdatetime" 2367 encoder.SetHeader(locationName).String(smithytime.FormatDateTime(*v.MemberDateTime)) 2368 } 2369 2370 if v.MemberEpochSeconds != nil { 2371 locationName := "X-Memberepochseconds" 2372 encoder.SetHeader(locationName).Double(smithytime.FormatEpochSeconds(*v.MemberEpochSeconds)) 2373 } 2374 2375 if v.MemberHttpDate != nil { 2376 locationName := "X-Memberhttpdate" 2377 encoder.SetHeader(locationName).String(smithytime.FormatHTTPDate(*v.MemberHttpDate)) 2378 } 2379 2380 if v.TargetDateTime != nil { 2381 locationName := "X-Targetdatetime" 2382 encoder.SetHeader(locationName).String(smithytime.FormatDateTime(*v.TargetDateTime)) 2383 } 2384 2385 if v.TargetEpochSeconds != nil { 2386 locationName := "X-Targetepochseconds" 2387 encoder.SetHeader(locationName).Double(smithytime.FormatEpochSeconds(*v.TargetEpochSeconds)) 2388 } 2389 2390 if v.TargetHttpDate != nil { 2391 locationName := "X-Targethttpdate" 2392 encoder.SetHeader(locationName).String(smithytime.FormatHTTPDate(*v.TargetHttpDate)) 2393 } 2394 2395 return nil 2396} 2397 2398type awsRestxml_serializeOpXmlAttributes struct { 2399} 2400 2401func (*awsRestxml_serializeOpXmlAttributes) ID() string { 2402 return "OperationSerializer" 2403} 2404 2405func (m *awsRestxml_serializeOpXmlAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2406 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2407) { 2408 request, ok := in.Request.(*smithyhttp.Request) 2409 if !ok { 2410 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2411 } 2412 2413 input, ok := in.Parameters.(*XmlAttributesInput) 2414 _ = input 2415 if !ok { 2416 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2417 } 2418 2419 opPath, opQuery := httpbinding.SplitURI("/XmlAttributes") 2420 request.URL.Path = opPath 2421 if len(request.URL.RawQuery) > 0 { 2422 request.URL.RawQuery = "&" + opQuery 2423 } else { 2424 request.URL.RawQuery = opQuery 2425 } 2426 2427 request.Method = "PUT" 2428 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2429 if err != nil { 2430 return out, metadata, &smithy.SerializationError{Err: err} 2431 } 2432 2433 restEncoder.SetHeader("Content-Type").String("application/xml") 2434 2435 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2436 rootAttr := []smithyxml.Attr{} 2437 if input.Attr != nil { 2438 var av string 2439 av = *input.Attr 2440 rootAttr = append(rootAttr, smithyxml.NewAttribute("test", av)) 2441 } 2442 root := smithyxml.StartElement{ 2443 Name: smithyxml.Name{ 2444 Local: "XmlAttributesInputOutput", 2445 }, 2446 Attr: rootAttr, 2447 } 2448 if err := awsRestxml_serializeOpDocumentXmlAttributesInput(input, xmlEncoder.RootElement(root)); err != nil { 2449 return out, metadata, &smithy.SerializationError{Err: err} 2450 } 2451 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2452 return out, metadata, &smithy.SerializationError{Err: err} 2453 } 2454 2455 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2456 return out, metadata, &smithy.SerializationError{Err: err} 2457 } 2458 in.Request = request 2459 2460 return next.HandleSerialize(ctx, in) 2461} 2462func awsRestxml_serializeOpHttpBindingsXmlAttributesInput(v *XmlAttributesInput, encoder *httpbinding.Encoder) error { 2463 if v == nil { 2464 return fmt.Errorf("unsupported serialization of nil %T", v) 2465 } 2466 2467 return nil 2468} 2469 2470func awsRestxml_serializeOpDocumentXmlAttributesInput(v *XmlAttributesInput, value smithyxml.Value) error { 2471 defer value.Close() 2472 if v.Foo != nil { 2473 rootAttr := []smithyxml.Attr{} 2474 root := smithyxml.StartElement{ 2475 Name: smithyxml.Name{ 2476 Local: "foo", 2477 }, 2478 Attr: rootAttr, 2479 } 2480 el := value.MemberElement(root) 2481 el.String(*v.Foo) 2482 } 2483 return nil 2484} 2485 2486type awsRestxml_serializeOpXmlAttributesOnPayload struct { 2487} 2488 2489func (*awsRestxml_serializeOpXmlAttributesOnPayload) ID() string { 2490 return "OperationSerializer" 2491} 2492 2493func (m *awsRestxml_serializeOpXmlAttributesOnPayload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2494 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2495) { 2496 request, ok := in.Request.(*smithyhttp.Request) 2497 if !ok { 2498 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2499 } 2500 2501 input, ok := in.Parameters.(*XmlAttributesOnPayloadInput) 2502 _ = input 2503 if !ok { 2504 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2505 } 2506 2507 opPath, opQuery := httpbinding.SplitURI("/XmlAttributesOnPayload") 2508 request.URL.Path = opPath 2509 if len(request.URL.RawQuery) > 0 { 2510 request.URL.RawQuery = "&" + opQuery 2511 } else { 2512 request.URL.RawQuery = opQuery 2513 } 2514 2515 request.Method = "PUT" 2516 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2517 if err != nil { 2518 return out, metadata, &smithy.SerializationError{Err: err} 2519 } 2520 2521 if input.Payload != nil { 2522 if !restEncoder.HasHeader("Content-Type") { 2523 restEncoder.SetHeader("Content-Type").String("application/xml") 2524 } 2525 2526 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2527 payloadRootAttr := []smithyxml.Attr{} 2528 if input.Payload.Attr != nil { 2529 var av string 2530 av = *input.Payload.Attr 2531 payloadRootAttr = append(payloadRootAttr, smithyxml.NewAttribute("test", av)) 2532 } 2533 payloadRoot := smithyxml.StartElement{ 2534 Name: smithyxml.Name{ 2535 Local: "XmlAttributesInputOutput", 2536 }, 2537 Attr: payloadRootAttr, 2538 } 2539 if err := awsRestxml_serializeDocumentXmlAttributesInputOutput(input.Payload, xmlEncoder.RootElement(payloadRoot)); err != nil { 2540 return out, metadata, &smithy.SerializationError{Err: err} 2541 } 2542 payload := bytes.NewReader(xmlEncoder.Bytes()) 2543 if request, err = request.SetStream(payload); err != nil { 2544 return out, metadata, &smithy.SerializationError{Err: err} 2545 } 2546 } 2547 2548 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2549 return out, metadata, &smithy.SerializationError{Err: err} 2550 } 2551 in.Request = request 2552 2553 return next.HandleSerialize(ctx, in) 2554} 2555func awsRestxml_serializeOpHttpBindingsXmlAttributesOnPayloadInput(v *XmlAttributesOnPayloadInput, encoder *httpbinding.Encoder) error { 2556 if v == nil { 2557 return fmt.Errorf("unsupported serialization of nil %T", v) 2558 } 2559 2560 return nil 2561} 2562 2563type awsRestxml_serializeOpXmlBlobs struct { 2564} 2565 2566func (*awsRestxml_serializeOpXmlBlobs) ID() string { 2567 return "OperationSerializer" 2568} 2569 2570func (m *awsRestxml_serializeOpXmlBlobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2571 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2572) { 2573 request, ok := in.Request.(*smithyhttp.Request) 2574 if !ok { 2575 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2576 } 2577 2578 input, ok := in.Parameters.(*XmlBlobsInput) 2579 _ = input 2580 if !ok { 2581 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2582 } 2583 2584 opPath, opQuery := httpbinding.SplitURI("/XmlBlobs") 2585 request.URL.Path = opPath 2586 if len(request.URL.RawQuery) > 0 { 2587 request.URL.RawQuery = "&" + opQuery 2588 } else { 2589 request.URL.RawQuery = opQuery 2590 } 2591 2592 request.Method = "POST" 2593 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2594 if err != nil { 2595 return out, metadata, &smithy.SerializationError{Err: err} 2596 } 2597 2598 restEncoder.SetHeader("Content-Type").String("application/xml") 2599 2600 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2601 rootAttr := []smithyxml.Attr{} 2602 root := smithyxml.StartElement{ 2603 Name: smithyxml.Name{ 2604 Local: "XmlBlobsInputOutput", 2605 }, 2606 Attr: rootAttr, 2607 } 2608 if err := awsRestxml_serializeOpDocumentXmlBlobsInput(input, xmlEncoder.RootElement(root)); err != nil { 2609 return out, metadata, &smithy.SerializationError{Err: err} 2610 } 2611 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2612 return out, metadata, &smithy.SerializationError{Err: err} 2613 } 2614 2615 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2616 return out, metadata, &smithy.SerializationError{Err: err} 2617 } 2618 in.Request = request 2619 2620 return next.HandleSerialize(ctx, in) 2621} 2622func awsRestxml_serializeOpHttpBindingsXmlBlobsInput(v *XmlBlobsInput, encoder *httpbinding.Encoder) error { 2623 if v == nil { 2624 return fmt.Errorf("unsupported serialization of nil %T", v) 2625 } 2626 2627 return nil 2628} 2629 2630func awsRestxml_serializeOpDocumentXmlBlobsInput(v *XmlBlobsInput, value smithyxml.Value) error { 2631 defer value.Close() 2632 if v.Data != nil { 2633 rootAttr := []smithyxml.Attr{} 2634 root := smithyxml.StartElement{ 2635 Name: smithyxml.Name{ 2636 Local: "data", 2637 }, 2638 Attr: rootAttr, 2639 } 2640 el := value.MemberElement(root) 2641 el.Base64EncodeBytes(v.Data) 2642 } 2643 return nil 2644} 2645 2646type awsRestxml_serializeOpXmlEmptyBlobs struct { 2647} 2648 2649func (*awsRestxml_serializeOpXmlEmptyBlobs) ID() string { 2650 return "OperationSerializer" 2651} 2652 2653func (m *awsRestxml_serializeOpXmlEmptyBlobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2654 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2655) { 2656 request, ok := in.Request.(*smithyhttp.Request) 2657 if !ok { 2658 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2659 } 2660 2661 input, ok := in.Parameters.(*XmlEmptyBlobsInput) 2662 _ = input 2663 if !ok { 2664 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2665 } 2666 2667 opPath, opQuery := httpbinding.SplitURI("/XmlEmptyBlobs") 2668 request.URL.Path = opPath 2669 if len(request.URL.RawQuery) > 0 { 2670 request.URL.RawQuery = "&" + opQuery 2671 } else { 2672 request.URL.RawQuery = opQuery 2673 } 2674 2675 request.Method = "POST" 2676 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2677 if err != nil { 2678 return out, metadata, &smithy.SerializationError{Err: err} 2679 } 2680 2681 restEncoder.SetHeader("Content-Type").String("application/xml") 2682 2683 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2684 rootAttr := []smithyxml.Attr{} 2685 root := smithyxml.StartElement{ 2686 Name: smithyxml.Name{ 2687 Local: "XmlBlobsInputOutput", 2688 }, 2689 Attr: rootAttr, 2690 } 2691 if err := awsRestxml_serializeOpDocumentXmlEmptyBlobsInput(input, xmlEncoder.RootElement(root)); err != nil { 2692 return out, metadata, &smithy.SerializationError{Err: err} 2693 } 2694 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2695 return out, metadata, &smithy.SerializationError{Err: err} 2696 } 2697 2698 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2699 return out, metadata, &smithy.SerializationError{Err: err} 2700 } 2701 in.Request = request 2702 2703 return next.HandleSerialize(ctx, in) 2704} 2705func awsRestxml_serializeOpHttpBindingsXmlEmptyBlobsInput(v *XmlEmptyBlobsInput, encoder *httpbinding.Encoder) error { 2706 if v == nil { 2707 return fmt.Errorf("unsupported serialization of nil %T", v) 2708 } 2709 2710 return nil 2711} 2712 2713func awsRestxml_serializeOpDocumentXmlEmptyBlobsInput(v *XmlEmptyBlobsInput, value smithyxml.Value) error { 2714 defer value.Close() 2715 if v.Data != nil { 2716 rootAttr := []smithyxml.Attr{} 2717 root := smithyxml.StartElement{ 2718 Name: smithyxml.Name{ 2719 Local: "data", 2720 }, 2721 Attr: rootAttr, 2722 } 2723 el := value.MemberElement(root) 2724 el.Base64EncodeBytes(v.Data) 2725 } 2726 return nil 2727} 2728 2729type awsRestxml_serializeOpXmlEmptyLists struct { 2730} 2731 2732func (*awsRestxml_serializeOpXmlEmptyLists) ID() string { 2733 return "OperationSerializer" 2734} 2735 2736func (m *awsRestxml_serializeOpXmlEmptyLists) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2737 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2738) { 2739 request, ok := in.Request.(*smithyhttp.Request) 2740 if !ok { 2741 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2742 } 2743 2744 input, ok := in.Parameters.(*XmlEmptyListsInput) 2745 _ = input 2746 if !ok { 2747 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2748 } 2749 2750 opPath, opQuery := httpbinding.SplitURI("/XmlEmptyLists") 2751 request.URL.Path = opPath 2752 if len(request.URL.RawQuery) > 0 { 2753 request.URL.RawQuery = "&" + opQuery 2754 } else { 2755 request.URL.RawQuery = opQuery 2756 } 2757 2758 request.Method = "PUT" 2759 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2760 if err != nil { 2761 return out, metadata, &smithy.SerializationError{Err: err} 2762 } 2763 2764 restEncoder.SetHeader("Content-Type").String("application/xml") 2765 2766 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2767 rootAttr := []smithyxml.Attr{} 2768 root := smithyxml.StartElement{ 2769 Name: smithyxml.Name{ 2770 Local: "XmlListsInputOutput", 2771 }, 2772 Attr: rootAttr, 2773 } 2774 if err := awsRestxml_serializeOpDocumentXmlEmptyListsInput(input, xmlEncoder.RootElement(root)); err != nil { 2775 return out, metadata, &smithy.SerializationError{Err: err} 2776 } 2777 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2778 return out, metadata, &smithy.SerializationError{Err: err} 2779 } 2780 2781 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2782 return out, metadata, &smithy.SerializationError{Err: err} 2783 } 2784 in.Request = request 2785 2786 return next.HandleSerialize(ctx, in) 2787} 2788func awsRestxml_serializeOpHttpBindingsXmlEmptyListsInput(v *XmlEmptyListsInput, encoder *httpbinding.Encoder) error { 2789 if v == nil { 2790 return fmt.Errorf("unsupported serialization of nil %T", v) 2791 } 2792 2793 return nil 2794} 2795 2796func awsRestxml_serializeOpDocumentXmlEmptyListsInput(v *XmlEmptyListsInput, value smithyxml.Value) error { 2797 defer value.Close() 2798 if v.BooleanList != nil { 2799 rootAttr := []smithyxml.Attr{} 2800 root := smithyxml.StartElement{ 2801 Name: smithyxml.Name{ 2802 Local: "booleanList", 2803 }, 2804 Attr: rootAttr, 2805 } 2806 el := value.MemberElement(root) 2807 if err := awsRestxml_serializeDocumentBooleanList(v.BooleanList, el); err != nil { 2808 return err 2809 } 2810 } 2811 if v.EnumList != nil { 2812 rootAttr := []smithyxml.Attr{} 2813 root := smithyxml.StartElement{ 2814 Name: smithyxml.Name{ 2815 Local: "enumList", 2816 }, 2817 Attr: rootAttr, 2818 } 2819 el := value.MemberElement(root) 2820 if err := awsRestxml_serializeDocumentFooEnumList(v.EnumList, el); err != nil { 2821 return err 2822 } 2823 } 2824 if v.FlattenedList != nil { 2825 rootAttr := []smithyxml.Attr{} 2826 root := smithyxml.StartElement{ 2827 Name: smithyxml.Name{ 2828 Local: "flattenedList", 2829 }, 2830 Attr: rootAttr, 2831 } 2832 el := value.FlattenedElement(root) 2833 if err := awsRestxml_serializeDocumentRenamedListMembers(v.FlattenedList, el); err != nil { 2834 return err 2835 } 2836 } 2837 if v.FlattenedList2 != nil { 2838 rootAttr := []smithyxml.Attr{} 2839 root := smithyxml.StartElement{ 2840 Name: smithyxml.Name{ 2841 Local: "customName", 2842 }, 2843 Attr: rootAttr, 2844 } 2845 el := value.FlattenedElement(root) 2846 if err := awsRestxml_serializeDocumentRenamedListMembers(v.FlattenedList2, el); err != nil { 2847 return err 2848 } 2849 } 2850 if v.FlattenedListWithMemberNamespace != nil { 2851 rootAttr := []smithyxml.Attr{} 2852 root := smithyxml.StartElement{ 2853 Name: smithyxml.Name{ 2854 Local: "flattenedListWithMemberNamespace", 2855 }, 2856 Attr: rootAttr, 2857 } 2858 el := value.FlattenedElement(root) 2859 if err := awsRestxml_serializeDocumentListWithMemberNamespace(v.FlattenedListWithMemberNamespace, el); err != nil { 2860 return err 2861 } 2862 } 2863 if v.FlattenedListWithNamespace != nil { 2864 rootAttr := []smithyxml.Attr{} 2865 root := smithyxml.StartElement{ 2866 Name: smithyxml.Name{ 2867 Local: "flattenedListWithNamespace", 2868 }, 2869 Attr: rootAttr, 2870 } 2871 el := value.FlattenedElement(root) 2872 if err := awsRestxml_serializeDocumentListWithNamespace(v.FlattenedListWithNamespace, el); err != nil { 2873 return err 2874 } 2875 } 2876 if v.IntegerList != nil { 2877 rootAttr := []smithyxml.Attr{} 2878 root := smithyxml.StartElement{ 2879 Name: smithyxml.Name{ 2880 Local: "integerList", 2881 }, 2882 Attr: rootAttr, 2883 } 2884 el := value.MemberElement(root) 2885 if err := awsRestxml_serializeDocumentIntegerList(v.IntegerList, el); err != nil { 2886 return err 2887 } 2888 } 2889 if v.NestedStringList != nil { 2890 rootAttr := []smithyxml.Attr{} 2891 root := smithyxml.StartElement{ 2892 Name: smithyxml.Name{ 2893 Local: "nestedStringList", 2894 }, 2895 Attr: rootAttr, 2896 } 2897 el := value.MemberElement(root) 2898 if err := awsRestxml_serializeDocumentNestedStringList(v.NestedStringList, el); err != nil { 2899 return err 2900 } 2901 } 2902 if v.RenamedListMembers != nil { 2903 rootAttr := []smithyxml.Attr{} 2904 root := smithyxml.StartElement{ 2905 Name: smithyxml.Name{ 2906 Local: "renamed", 2907 }, 2908 Attr: rootAttr, 2909 } 2910 el := value.MemberElement(root) 2911 if err := awsRestxml_serializeDocumentRenamedListMembers(v.RenamedListMembers, el); err != nil { 2912 return err 2913 } 2914 } 2915 if v.StringList != nil { 2916 rootAttr := []smithyxml.Attr{} 2917 root := smithyxml.StartElement{ 2918 Name: smithyxml.Name{ 2919 Local: "stringList", 2920 }, 2921 Attr: rootAttr, 2922 } 2923 el := value.MemberElement(root) 2924 if err := awsRestxml_serializeDocumentStringList(v.StringList, el); err != nil { 2925 return err 2926 } 2927 } 2928 if v.StringSet != nil { 2929 rootAttr := []smithyxml.Attr{} 2930 root := smithyxml.StartElement{ 2931 Name: smithyxml.Name{ 2932 Local: "stringSet", 2933 }, 2934 Attr: rootAttr, 2935 } 2936 el := value.MemberElement(root) 2937 if err := awsRestxml_serializeDocumentStringSet(v.StringSet, el); err != nil { 2938 return err 2939 } 2940 } 2941 if v.StructureList != nil { 2942 rootAttr := []smithyxml.Attr{} 2943 root := smithyxml.StartElement{ 2944 Name: smithyxml.Name{ 2945 Local: "myStructureList", 2946 }, 2947 Attr: rootAttr, 2948 } 2949 el := value.MemberElement(root) 2950 if err := awsRestxml_serializeDocumentStructureList(v.StructureList, el); err != nil { 2951 return err 2952 } 2953 } 2954 if v.TimestampList != nil { 2955 rootAttr := []smithyxml.Attr{} 2956 root := smithyxml.StartElement{ 2957 Name: smithyxml.Name{ 2958 Local: "timestampList", 2959 }, 2960 Attr: rootAttr, 2961 } 2962 el := value.MemberElement(root) 2963 if err := awsRestxml_serializeDocumentTimestampList(v.TimestampList, el); err != nil { 2964 return err 2965 } 2966 } 2967 return nil 2968} 2969 2970type awsRestxml_serializeOpXmlEmptyMaps struct { 2971} 2972 2973func (*awsRestxml_serializeOpXmlEmptyMaps) ID() string { 2974 return "OperationSerializer" 2975} 2976 2977func (m *awsRestxml_serializeOpXmlEmptyMaps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2978 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2979) { 2980 request, ok := in.Request.(*smithyhttp.Request) 2981 if !ok { 2982 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2983 } 2984 2985 input, ok := in.Parameters.(*XmlEmptyMapsInput) 2986 _ = input 2987 if !ok { 2988 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2989 } 2990 2991 opPath, opQuery := httpbinding.SplitURI("/XmlEmptyMaps") 2992 request.URL.Path = opPath 2993 if len(request.URL.RawQuery) > 0 { 2994 request.URL.RawQuery = "&" + opQuery 2995 } else { 2996 request.URL.RawQuery = opQuery 2997 } 2998 2999 request.Method = "POST" 3000 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3001 if err != nil { 3002 return out, metadata, &smithy.SerializationError{Err: err} 3003 } 3004 3005 restEncoder.SetHeader("Content-Type").String("application/xml") 3006 3007 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3008 rootAttr := []smithyxml.Attr{} 3009 root := smithyxml.StartElement{ 3010 Name: smithyxml.Name{ 3011 Local: "XmlMapsInputOutput", 3012 }, 3013 Attr: rootAttr, 3014 } 3015 if err := awsRestxml_serializeOpDocumentXmlEmptyMapsInput(input, xmlEncoder.RootElement(root)); err != nil { 3016 return out, metadata, &smithy.SerializationError{Err: err} 3017 } 3018 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3019 return out, metadata, &smithy.SerializationError{Err: err} 3020 } 3021 3022 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3023 return out, metadata, &smithy.SerializationError{Err: err} 3024 } 3025 in.Request = request 3026 3027 return next.HandleSerialize(ctx, in) 3028} 3029func awsRestxml_serializeOpHttpBindingsXmlEmptyMapsInput(v *XmlEmptyMapsInput, encoder *httpbinding.Encoder) error { 3030 if v == nil { 3031 return fmt.Errorf("unsupported serialization of nil %T", v) 3032 } 3033 3034 return nil 3035} 3036 3037func awsRestxml_serializeOpDocumentXmlEmptyMapsInput(v *XmlEmptyMapsInput, value smithyxml.Value) error { 3038 defer value.Close() 3039 if v.MyMap != nil { 3040 rootAttr := []smithyxml.Attr{} 3041 root := smithyxml.StartElement{ 3042 Name: smithyxml.Name{ 3043 Local: "myMap", 3044 }, 3045 Attr: rootAttr, 3046 } 3047 el := value.MemberElement(root) 3048 if err := awsRestxml_serializeDocumentXmlMapsInputOutputMap(v.MyMap, el); err != nil { 3049 return err 3050 } 3051 } 3052 return nil 3053} 3054 3055type awsRestxml_serializeOpXmlEmptyStrings struct { 3056} 3057 3058func (*awsRestxml_serializeOpXmlEmptyStrings) ID() string { 3059 return "OperationSerializer" 3060} 3061 3062func (m *awsRestxml_serializeOpXmlEmptyStrings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3063 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3064) { 3065 request, ok := in.Request.(*smithyhttp.Request) 3066 if !ok { 3067 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3068 } 3069 3070 input, ok := in.Parameters.(*XmlEmptyStringsInput) 3071 _ = input 3072 if !ok { 3073 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3074 } 3075 3076 opPath, opQuery := httpbinding.SplitURI("/XmlEmptyStrings") 3077 request.URL.Path = opPath 3078 if len(request.URL.RawQuery) > 0 { 3079 request.URL.RawQuery = "&" + opQuery 3080 } else { 3081 request.URL.RawQuery = opQuery 3082 } 3083 3084 request.Method = "PUT" 3085 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3086 if err != nil { 3087 return out, metadata, &smithy.SerializationError{Err: err} 3088 } 3089 3090 restEncoder.SetHeader("Content-Type").String("application/xml") 3091 3092 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3093 rootAttr := []smithyxml.Attr{} 3094 root := smithyxml.StartElement{ 3095 Name: smithyxml.Name{ 3096 Local: "XmlEmptyStringsInputOutput", 3097 }, 3098 Attr: rootAttr, 3099 } 3100 if err := awsRestxml_serializeOpDocumentXmlEmptyStringsInput(input, xmlEncoder.RootElement(root)); err != nil { 3101 return out, metadata, &smithy.SerializationError{Err: err} 3102 } 3103 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3104 return out, metadata, &smithy.SerializationError{Err: err} 3105 } 3106 3107 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3108 return out, metadata, &smithy.SerializationError{Err: err} 3109 } 3110 in.Request = request 3111 3112 return next.HandleSerialize(ctx, in) 3113} 3114func awsRestxml_serializeOpHttpBindingsXmlEmptyStringsInput(v *XmlEmptyStringsInput, encoder *httpbinding.Encoder) error { 3115 if v == nil { 3116 return fmt.Errorf("unsupported serialization of nil %T", v) 3117 } 3118 3119 return nil 3120} 3121 3122func awsRestxml_serializeOpDocumentXmlEmptyStringsInput(v *XmlEmptyStringsInput, value smithyxml.Value) error { 3123 defer value.Close() 3124 if v.EmptyString != nil { 3125 rootAttr := []smithyxml.Attr{} 3126 root := smithyxml.StartElement{ 3127 Name: smithyxml.Name{ 3128 Local: "emptyString", 3129 }, 3130 Attr: rootAttr, 3131 } 3132 el := value.MemberElement(root) 3133 el.String(*v.EmptyString) 3134 } 3135 return nil 3136} 3137 3138type awsRestxml_serializeOpXmlEnums struct { 3139} 3140 3141func (*awsRestxml_serializeOpXmlEnums) ID() string { 3142 return "OperationSerializer" 3143} 3144 3145func (m *awsRestxml_serializeOpXmlEnums) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3146 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3147) { 3148 request, ok := in.Request.(*smithyhttp.Request) 3149 if !ok { 3150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3151 } 3152 3153 input, ok := in.Parameters.(*XmlEnumsInput) 3154 _ = input 3155 if !ok { 3156 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3157 } 3158 3159 opPath, opQuery := httpbinding.SplitURI("/XmlEnums") 3160 request.URL.Path = opPath 3161 if len(request.URL.RawQuery) > 0 { 3162 request.URL.RawQuery = "&" + opQuery 3163 } else { 3164 request.URL.RawQuery = opQuery 3165 } 3166 3167 request.Method = "PUT" 3168 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3169 if err != nil { 3170 return out, metadata, &smithy.SerializationError{Err: err} 3171 } 3172 3173 restEncoder.SetHeader("Content-Type").String("application/xml") 3174 3175 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3176 rootAttr := []smithyxml.Attr{} 3177 root := smithyxml.StartElement{ 3178 Name: smithyxml.Name{ 3179 Local: "XmlEnumsInputOutput", 3180 }, 3181 Attr: rootAttr, 3182 } 3183 if err := awsRestxml_serializeOpDocumentXmlEnumsInput(input, xmlEncoder.RootElement(root)); err != nil { 3184 return out, metadata, &smithy.SerializationError{Err: err} 3185 } 3186 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3187 return out, metadata, &smithy.SerializationError{Err: err} 3188 } 3189 3190 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3191 return out, metadata, &smithy.SerializationError{Err: err} 3192 } 3193 in.Request = request 3194 3195 return next.HandleSerialize(ctx, in) 3196} 3197func awsRestxml_serializeOpHttpBindingsXmlEnumsInput(v *XmlEnumsInput, encoder *httpbinding.Encoder) error { 3198 if v == nil { 3199 return fmt.Errorf("unsupported serialization of nil %T", v) 3200 } 3201 3202 return nil 3203} 3204 3205func awsRestxml_serializeOpDocumentXmlEnumsInput(v *XmlEnumsInput, value smithyxml.Value) error { 3206 defer value.Close() 3207 if len(v.FooEnum1) > 0 { 3208 rootAttr := []smithyxml.Attr{} 3209 root := smithyxml.StartElement{ 3210 Name: smithyxml.Name{ 3211 Local: "fooEnum1", 3212 }, 3213 Attr: rootAttr, 3214 } 3215 el := value.MemberElement(root) 3216 el.String(string(v.FooEnum1)) 3217 } 3218 if len(v.FooEnum2) > 0 { 3219 rootAttr := []smithyxml.Attr{} 3220 root := smithyxml.StartElement{ 3221 Name: smithyxml.Name{ 3222 Local: "fooEnum2", 3223 }, 3224 Attr: rootAttr, 3225 } 3226 el := value.MemberElement(root) 3227 el.String(string(v.FooEnum2)) 3228 } 3229 if len(v.FooEnum3) > 0 { 3230 rootAttr := []smithyxml.Attr{} 3231 root := smithyxml.StartElement{ 3232 Name: smithyxml.Name{ 3233 Local: "fooEnum3", 3234 }, 3235 Attr: rootAttr, 3236 } 3237 el := value.MemberElement(root) 3238 el.String(string(v.FooEnum3)) 3239 } 3240 if v.FooEnumList != nil { 3241 rootAttr := []smithyxml.Attr{} 3242 root := smithyxml.StartElement{ 3243 Name: smithyxml.Name{ 3244 Local: "fooEnumList", 3245 }, 3246 Attr: rootAttr, 3247 } 3248 el := value.MemberElement(root) 3249 if err := awsRestxml_serializeDocumentFooEnumList(v.FooEnumList, el); err != nil { 3250 return err 3251 } 3252 } 3253 if v.FooEnumMap != nil { 3254 rootAttr := []smithyxml.Attr{} 3255 root := smithyxml.StartElement{ 3256 Name: smithyxml.Name{ 3257 Local: "fooEnumMap", 3258 }, 3259 Attr: rootAttr, 3260 } 3261 el := value.MemberElement(root) 3262 if err := awsRestxml_serializeDocumentFooEnumMap(v.FooEnumMap, el); err != nil { 3263 return err 3264 } 3265 } 3266 if v.FooEnumSet != nil { 3267 rootAttr := []smithyxml.Attr{} 3268 root := smithyxml.StartElement{ 3269 Name: smithyxml.Name{ 3270 Local: "fooEnumSet", 3271 }, 3272 Attr: rootAttr, 3273 } 3274 el := value.MemberElement(root) 3275 if err := awsRestxml_serializeDocumentFooEnumSet(v.FooEnumSet, el); err != nil { 3276 return err 3277 } 3278 } 3279 return nil 3280} 3281 3282type awsRestxml_serializeOpXmlLists struct { 3283} 3284 3285func (*awsRestxml_serializeOpXmlLists) ID() string { 3286 return "OperationSerializer" 3287} 3288 3289func (m *awsRestxml_serializeOpXmlLists) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3290 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3291) { 3292 request, ok := in.Request.(*smithyhttp.Request) 3293 if !ok { 3294 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3295 } 3296 3297 input, ok := in.Parameters.(*XmlListsInput) 3298 _ = input 3299 if !ok { 3300 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3301 } 3302 3303 opPath, opQuery := httpbinding.SplitURI("/XmlLists") 3304 request.URL.Path = opPath 3305 if len(request.URL.RawQuery) > 0 { 3306 request.URL.RawQuery = "&" + opQuery 3307 } else { 3308 request.URL.RawQuery = opQuery 3309 } 3310 3311 request.Method = "PUT" 3312 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3313 if err != nil { 3314 return out, metadata, &smithy.SerializationError{Err: err} 3315 } 3316 3317 restEncoder.SetHeader("Content-Type").String("application/xml") 3318 3319 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3320 rootAttr := []smithyxml.Attr{} 3321 root := smithyxml.StartElement{ 3322 Name: smithyxml.Name{ 3323 Local: "XmlListsInputOutput", 3324 }, 3325 Attr: rootAttr, 3326 } 3327 if err := awsRestxml_serializeOpDocumentXmlListsInput(input, xmlEncoder.RootElement(root)); err != nil { 3328 return out, metadata, &smithy.SerializationError{Err: err} 3329 } 3330 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3331 return out, metadata, &smithy.SerializationError{Err: err} 3332 } 3333 3334 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3335 return out, metadata, &smithy.SerializationError{Err: err} 3336 } 3337 in.Request = request 3338 3339 return next.HandleSerialize(ctx, in) 3340} 3341func awsRestxml_serializeOpHttpBindingsXmlListsInput(v *XmlListsInput, encoder *httpbinding.Encoder) error { 3342 if v == nil { 3343 return fmt.Errorf("unsupported serialization of nil %T", v) 3344 } 3345 3346 return nil 3347} 3348 3349func awsRestxml_serializeOpDocumentXmlListsInput(v *XmlListsInput, value smithyxml.Value) error { 3350 defer value.Close() 3351 if v.BooleanList != nil { 3352 rootAttr := []smithyxml.Attr{} 3353 root := smithyxml.StartElement{ 3354 Name: smithyxml.Name{ 3355 Local: "booleanList", 3356 }, 3357 Attr: rootAttr, 3358 } 3359 el := value.MemberElement(root) 3360 if err := awsRestxml_serializeDocumentBooleanList(v.BooleanList, el); err != nil { 3361 return err 3362 } 3363 } 3364 if v.EnumList != nil { 3365 rootAttr := []smithyxml.Attr{} 3366 root := smithyxml.StartElement{ 3367 Name: smithyxml.Name{ 3368 Local: "enumList", 3369 }, 3370 Attr: rootAttr, 3371 } 3372 el := value.MemberElement(root) 3373 if err := awsRestxml_serializeDocumentFooEnumList(v.EnumList, el); err != nil { 3374 return err 3375 } 3376 } 3377 if v.FlattenedList != nil { 3378 rootAttr := []smithyxml.Attr{} 3379 root := smithyxml.StartElement{ 3380 Name: smithyxml.Name{ 3381 Local: "flattenedList", 3382 }, 3383 Attr: rootAttr, 3384 } 3385 el := value.FlattenedElement(root) 3386 if err := awsRestxml_serializeDocumentRenamedListMembers(v.FlattenedList, el); err != nil { 3387 return err 3388 } 3389 } 3390 if v.FlattenedList2 != nil { 3391 rootAttr := []smithyxml.Attr{} 3392 root := smithyxml.StartElement{ 3393 Name: smithyxml.Name{ 3394 Local: "customName", 3395 }, 3396 Attr: rootAttr, 3397 } 3398 el := value.FlattenedElement(root) 3399 if err := awsRestxml_serializeDocumentRenamedListMembers(v.FlattenedList2, el); err != nil { 3400 return err 3401 } 3402 } 3403 if v.FlattenedListWithMemberNamespace != nil { 3404 rootAttr := []smithyxml.Attr{} 3405 root := smithyxml.StartElement{ 3406 Name: smithyxml.Name{ 3407 Local: "flattenedListWithMemberNamespace", 3408 }, 3409 Attr: rootAttr, 3410 } 3411 el := value.FlattenedElement(root) 3412 if err := awsRestxml_serializeDocumentListWithMemberNamespace(v.FlattenedListWithMemberNamespace, el); err != nil { 3413 return err 3414 } 3415 } 3416 if v.FlattenedListWithNamespace != nil { 3417 rootAttr := []smithyxml.Attr{} 3418 root := smithyxml.StartElement{ 3419 Name: smithyxml.Name{ 3420 Local: "flattenedListWithNamespace", 3421 }, 3422 Attr: rootAttr, 3423 } 3424 el := value.FlattenedElement(root) 3425 if err := awsRestxml_serializeDocumentListWithNamespace(v.FlattenedListWithNamespace, el); err != nil { 3426 return err 3427 } 3428 } 3429 if v.IntegerList != nil { 3430 rootAttr := []smithyxml.Attr{} 3431 root := smithyxml.StartElement{ 3432 Name: smithyxml.Name{ 3433 Local: "integerList", 3434 }, 3435 Attr: rootAttr, 3436 } 3437 el := value.MemberElement(root) 3438 if err := awsRestxml_serializeDocumentIntegerList(v.IntegerList, el); err != nil { 3439 return err 3440 } 3441 } 3442 if v.NestedStringList != nil { 3443 rootAttr := []smithyxml.Attr{} 3444 root := smithyxml.StartElement{ 3445 Name: smithyxml.Name{ 3446 Local: "nestedStringList", 3447 }, 3448 Attr: rootAttr, 3449 } 3450 el := value.MemberElement(root) 3451 if err := awsRestxml_serializeDocumentNestedStringList(v.NestedStringList, el); err != nil { 3452 return err 3453 } 3454 } 3455 if v.RenamedListMembers != nil { 3456 rootAttr := []smithyxml.Attr{} 3457 root := smithyxml.StartElement{ 3458 Name: smithyxml.Name{ 3459 Local: "renamed", 3460 }, 3461 Attr: rootAttr, 3462 } 3463 el := value.MemberElement(root) 3464 if err := awsRestxml_serializeDocumentRenamedListMembers(v.RenamedListMembers, el); err != nil { 3465 return err 3466 } 3467 } 3468 if v.StringList != nil { 3469 rootAttr := []smithyxml.Attr{} 3470 root := smithyxml.StartElement{ 3471 Name: smithyxml.Name{ 3472 Local: "stringList", 3473 }, 3474 Attr: rootAttr, 3475 } 3476 el := value.MemberElement(root) 3477 if err := awsRestxml_serializeDocumentStringList(v.StringList, el); err != nil { 3478 return err 3479 } 3480 } 3481 if v.StringSet != nil { 3482 rootAttr := []smithyxml.Attr{} 3483 root := smithyxml.StartElement{ 3484 Name: smithyxml.Name{ 3485 Local: "stringSet", 3486 }, 3487 Attr: rootAttr, 3488 } 3489 el := value.MemberElement(root) 3490 if err := awsRestxml_serializeDocumentStringSet(v.StringSet, el); err != nil { 3491 return err 3492 } 3493 } 3494 if v.StructureList != nil { 3495 rootAttr := []smithyxml.Attr{} 3496 root := smithyxml.StartElement{ 3497 Name: smithyxml.Name{ 3498 Local: "myStructureList", 3499 }, 3500 Attr: rootAttr, 3501 } 3502 el := value.MemberElement(root) 3503 if err := awsRestxml_serializeDocumentStructureList(v.StructureList, el); err != nil { 3504 return err 3505 } 3506 } 3507 if v.TimestampList != nil { 3508 rootAttr := []smithyxml.Attr{} 3509 root := smithyxml.StartElement{ 3510 Name: smithyxml.Name{ 3511 Local: "timestampList", 3512 }, 3513 Attr: rootAttr, 3514 } 3515 el := value.MemberElement(root) 3516 if err := awsRestxml_serializeDocumentTimestampList(v.TimestampList, el); err != nil { 3517 return err 3518 } 3519 } 3520 return nil 3521} 3522 3523type awsRestxml_serializeOpXmlMaps struct { 3524} 3525 3526func (*awsRestxml_serializeOpXmlMaps) ID() string { 3527 return "OperationSerializer" 3528} 3529 3530func (m *awsRestxml_serializeOpXmlMaps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3531 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3532) { 3533 request, ok := in.Request.(*smithyhttp.Request) 3534 if !ok { 3535 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3536 } 3537 3538 input, ok := in.Parameters.(*XmlMapsInput) 3539 _ = input 3540 if !ok { 3541 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3542 } 3543 3544 opPath, opQuery := httpbinding.SplitURI("/XmlMaps") 3545 request.URL.Path = opPath 3546 if len(request.URL.RawQuery) > 0 { 3547 request.URL.RawQuery = "&" + opQuery 3548 } else { 3549 request.URL.RawQuery = opQuery 3550 } 3551 3552 request.Method = "POST" 3553 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3554 if err != nil { 3555 return out, metadata, &smithy.SerializationError{Err: err} 3556 } 3557 3558 restEncoder.SetHeader("Content-Type").String("application/xml") 3559 3560 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3561 rootAttr := []smithyxml.Attr{} 3562 root := smithyxml.StartElement{ 3563 Name: smithyxml.Name{ 3564 Local: "XmlMapsInputOutput", 3565 }, 3566 Attr: rootAttr, 3567 } 3568 if err := awsRestxml_serializeOpDocumentXmlMapsInput(input, xmlEncoder.RootElement(root)); err != nil { 3569 return out, metadata, &smithy.SerializationError{Err: err} 3570 } 3571 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3572 return out, metadata, &smithy.SerializationError{Err: err} 3573 } 3574 3575 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3576 return out, metadata, &smithy.SerializationError{Err: err} 3577 } 3578 in.Request = request 3579 3580 return next.HandleSerialize(ctx, in) 3581} 3582func awsRestxml_serializeOpHttpBindingsXmlMapsInput(v *XmlMapsInput, encoder *httpbinding.Encoder) error { 3583 if v == nil { 3584 return fmt.Errorf("unsupported serialization of nil %T", v) 3585 } 3586 3587 return nil 3588} 3589 3590func awsRestxml_serializeOpDocumentXmlMapsInput(v *XmlMapsInput, value smithyxml.Value) error { 3591 defer value.Close() 3592 if v.MyMap != nil { 3593 rootAttr := []smithyxml.Attr{} 3594 root := smithyxml.StartElement{ 3595 Name: smithyxml.Name{ 3596 Local: "myMap", 3597 }, 3598 Attr: rootAttr, 3599 } 3600 el := value.MemberElement(root) 3601 if err := awsRestxml_serializeDocumentXmlMapsInputOutputMap(v.MyMap, el); err != nil { 3602 return err 3603 } 3604 } 3605 return nil 3606} 3607 3608type awsRestxml_serializeOpXmlMapsXmlName struct { 3609} 3610 3611func (*awsRestxml_serializeOpXmlMapsXmlName) ID() string { 3612 return "OperationSerializer" 3613} 3614 3615func (m *awsRestxml_serializeOpXmlMapsXmlName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3616 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3617) { 3618 request, ok := in.Request.(*smithyhttp.Request) 3619 if !ok { 3620 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3621 } 3622 3623 input, ok := in.Parameters.(*XmlMapsXmlNameInput) 3624 _ = input 3625 if !ok { 3626 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3627 } 3628 3629 opPath, opQuery := httpbinding.SplitURI("/XmlMapsXmlName") 3630 request.URL.Path = opPath 3631 if len(request.URL.RawQuery) > 0 { 3632 request.URL.RawQuery = "&" + opQuery 3633 } else { 3634 request.URL.RawQuery = opQuery 3635 } 3636 3637 request.Method = "POST" 3638 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3639 if err != nil { 3640 return out, metadata, &smithy.SerializationError{Err: err} 3641 } 3642 3643 restEncoder.SetHeader("Content-Type").String("application/xml") 3644 3645 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3646 rootAttr := []smithyxml.Attr{} 3647 root := smithyxml.StartElement{ 3648 Name: smithyxml.Name{ 3649 Local: "XmlMapsXmlNameInputOutput", 3650 }, 3651 Attr: rootAttr, 3652 } 3653 if err := awsRestxml_serializeOpDocumentXmlMapsXmlNameInput(input, xmlEncoder.RootElement(root)); err != nil { 3654 return out, metadata, &smithy.SerializationError{Err: err} 3655 } 3656 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3657 return out, metadata, &smithy.SerializationError{Err: err} 3658 } 3659 3660 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3661 return out, metadata, &smithy.SerializationError{Err: err} 3662 } 3663 in.Request = request 3664 3665 return next.HandleSerialize(ctx, in) 3666} 3667func awsRestxml_serializeOpHttpBindingsXmlMapsXmlNameInput(v *XmlMapsXmlNameInput, encoder *httpbinding.Encoder) error { 3668 if v == nil { 3669 return fmt.Errorf("unsupported serialization of nil %T", v) 3670 } 3671 3672 return nil 3673} 3674 3675func awsRestxml_serializeOpDocumentXmlMapsXmlNameInput(v *XmlMapsXmlNameInput, value smithyxml.Value) error { 3676 defer value.Close() 3677 if v.MyMap != nil { 3678 rootAttr := []smithyxml.Attr{} 3679 root := smithyxml.StartElement{ 3680 Name: smithyxml.Name{ 3681 Local: "myMap", 3682 }, 3683 Attr: rootAttr, 3684 } 3685 el := value.MemberElement(root) 3686 if err := awsRestxml_serializeDocumentXmlMapsXmlNameInputOutputMap(v.MyMap, el); err != nil { 3687 return err 3688 } 3689 } 3690 return nil 3691} 3692 3693type awsRestxml_serializeOpXmlNamespaces struct { 3694} 3695 3696func (*awsRestxml_serializeOpXmlNamespaces) ID() string { 3697 return "OperationSerializer" 3698} 3699 3700func (m *awsRestxml_serializeOpXmlNamespaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3701 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3702) { 3703 request, ok := in.Request.(*smithyhttp.Request) 3704 if !ok { 3705 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3706 } 3707 3708 input, ok := in.Parameters.(*XmlNamespacesInput) 3709 _ = input 3710 if !ok { 3711 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3712 } 3713 3714 opPath, opQuery := httpbinding.SplitURI("/XmlNamespaces") 3715 request.URL.Path = opPath 3716 if len(request.URL.RawQuery) > 0 { 3717 request.URL.RawQuery = "&" + opQuery 3718 } else { 3719 request.URL.RawQuery = opQuery 3720 } 3721 3722 request.Method = "POST" 3723 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3724 if err != nil { 3725 return out, metadata, &smithy.SerializationError{Err: err} 3726 } 3727 3728 restEncoder.SetHeader("Content-Type").String("application/xml") 3729 3730 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3731 rootAttr := []smithyxml.Attr{} 3732 rootAttr = append(rootAttr, smithyxml.NewNamespaceAttribute("", "http://foo.com")) 3733 root := smithyxml.StartElement{ 3734 Name: smithyxml.Name{ 3735 Local: "XmlNamespacesInputOutput", 3736 }, 3737 Attr: rootAttr, 3738 } 3739 if err := awsRestxml_serializeOpDocumentXmlNamespacesInput(input, xmlEncoder.RootElement(root)); err != nil { 3740 return out, metadata, &smithy.SerializationError{Err: err} 3741 } 3742 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3743 return out, metadata, &smithy.SerializationError{Err: err} 3744 } 3745 3746 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3747 return out, metadata, &smithy.SerializationError{Err: err} 3748 } 3749 in.Request = request 3750 3751 return next.HandleSerialize(ctx, in) 3752} 3753func awsRestxml_serializeOpHttpBindingsXmlNamespacesInput(v *XmlNamespacesInput, encoder *httpbinding.Encoder) error { 3754 if v == nil { 3755 return fmt.Errorf("unsupported serialization of nil %T", v) 3756 } 3757 3758 return nil 3759} 3760 3761func awsRestxml_serializeOpDocumentXmlNamespacesInput(v *XmlNamespacesInput, value smithyxml.Value) error { 3762 defer value.Close() 3763 if v.Nested != nil { 3764 rootAttr := []smithyxml.Attr{} 3765 root := smithyxml.StartElement{ 3766 Name: smithyxml.Name{ 3767 Local: "nested", 3768 }, 3769 Attr: rootAttr, 3770 } 3771 el := value.MemberElement(root) 3772 if err := awsRestxml_serializeDocumentXmlNamespaceNested(v.Nested, el); err != nil { 3773 return err 3774 } 3775 } 3776 return nil 3777} 3778 3779type awsRestxml_serializeOpXmlTimestamps struct { 3780} 3781 3782func (*awsRestxml_serializeOpXmlTimestamps) ID() string { 3783 return "OperationSerializer" 3784} 3785 3786func (m *awsRestxml_serializeOpXmlTimestamps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3787 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3788) { 3789 request, ok := in.Request.(*smithyhttp.Request) 3790 if !ok { 3791 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3792 } 3793 3794 input, ok := in.Parameters.(*XmlTimestampsInput) 3795 _ = input 3796 if !ok { 3797 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3798 } 3799 3800 opPath, opQuery := httpbinding.SplitURI("/XmlTimestamps") 3801 request.URL.Path = opPath 3802 if len(request.URL.RawQuery) > 0 { 3803 request.URL.RawQuery = "&" + opQuery 3804 } else { 3805 request.URL.RawQuery = opQuery 3806 } 3807 3808 request.Method = "POST" 3809 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3810 if err != nil { 3811 return out, metadata, &smithy.SerializationError{Err: err} 3812 } 3813 3814 restEncoder.SetHeader("Content-Type").String("application/xml") 3815 3816 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 3817 rootAttr := []smithyxml.Attr{} 3818 root := smithyxml.StartElement{ 3819 Name: smithyxml.Name{ 3820 Local: "XmlTimestampsInputOutput", 3821 }, 3822 Attr: rootAttr, 3823 } 3824 if err := awsRestxml_serializeOpDocumentXmlTimestampsInput(input, xmlEncoder.RootElement(root)); err != nil { 3825 return out, metadata, &smithy.SerializationError{Err: err} 3826 } 3827 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 3828 return out, metadata, &smithy.SerializationError{Err: err} 3829 } 3830 3831 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3832 return out, metadata, &smithy.SerializationError{Err: err} 3833 } 3834 in.Request = request 3835 3836 return next.HandleSerialize(ctx, in) 3837} 3838func awsRestxml_serializeOpHttpBindingsXmlTimestampsInput(v *XmlTimestampsInput, encoder *httpbinding.Encoder) error { 3839 if v == nil { 3840 return fmt.Errorf("unsupported serialization of nil %T", v) 3841 } 3842 3843 return nil 3844} 3845 3846func awsRestxml_serializeOpDocumentXmlTimestampsInput(v *XmlTimestampsInput, value smithyxml.Value) error { 3847 defer value.Close() 3848 if v.DateTime != nil { 3849 rootAttr := []smithyxml.Attr{} 3850 root := smithyxml.StartElement{ 3851 Name: smithyxml.Name{ 3852 Local: "dateTime", 3853 }, 3854 Attr: rootAttr, 3855 } 3856 el := value.MemberElement(root) 3857 el.String(smithytime.FormatDateTime(*v.DateTime)) 3858 } 3859 if v.EpochSeconds != nil { 3860 rootAttr := []smithyxml.Attr{} 3861 root := smithyxml.StartElement{ 3862 Name: smithyxml.Name{ 3863 Local: "epochSeconds", 3864 }, 3865 Attr: rootAttr, 3866 } 3867 el := value.MemberElement(root) 3868 el.Double(smithytime.FormatEpochSeconds(*v.EpochSeconds)) 3869 } 3870 if v.HttpDate != nil { 3871 rootAttr := []smithyxml.Attr{} 3872 root := smithyxml.StartElement{ 3873 Name: smithyxml.Name{ 3874 Local: "httpDate", 3875 }, 3876 Attr: rootAttr, 3877 } 3878 el := value.MemberElement(root) 3879 el.String(smithytime.FormatHTTPDate(*v.HttpDate)) 3880 } 3881 if v.Normal != nil { 3882 rootAttr := []smithyxml.Attr{} 3883 root := smithyxml.StartElement{ 3884 Name: smithyxml.Name{ 3885 Local: "normal", 3886 }, 3887 Attr: rootAttr, 3888 } 3889 el := value.MemberElement(root) 3890 el.String(smithytime.FormatDateTime(*v.Normal)) 3891 } 3892 return nil 3893} 3894 3895func awsRestxml_serializeDocumentFlattenedXmlMapWithXmlNameInputOutputMap(v map[string]string, value smithyxml.Value) error { 3896 if !value.IsFlattened() { 3897 defer value.Close() 3898 } 3899 m := value.Map() 3900 for key := range v { 3901 entry := m.Entry() 3902 keyElementAttr := []smithyxml.Attr{} 3903 keyElement := smithyxml.StartElement{ 3904 Name: smithyxml.Name{ 3905 Local: "K", 3906 }, 3907 Attr: keyElementAttr, 3908 } 3909 entry.MemberElement(keyElement).String(key) 3910 valueElementAttr := []smithyxml.Attr{} 3911 valueElement := smithyxml.StartElement{ 3912 Name: smithyxml.Name{ 3913 Local: "V", 3914 }, 3915 Attr: valueElementAttr, 3916 } 3917 entry.MemberElement(valueElement).String(v[key]) 3918 entry.Close() 3919 } 3920 return nil 3921} 3922 3923func awsRestxml_serializeDocumentListWithMemberNamespace(v []string, value smithyxml.Value) error { 3924 var array *smithyxml.Array 3925 if !value.IsFlattened() { 3926 defer value.Close() 3927 } 3928 customMemberNameAttr := []smithyxml.Attr{} 3929 customMemberNameAttr = append(customMemberNameAttr, smithyxml.NewNamespaceAttribute("", "https://xml-member.example.com")) 3930 customMemberName := smithyxml.StartElement{ 3931 Name: smithyxml.Name{ 3932 Local: "member", 3933 }, 3934 Attr: customMemberNameAttr, 3935 } 3936 array = value.ArrayWithCustomName(customMemberName) 3937 for i := range v { 3938 am := array.Member() 3939 am.String(v[i]) 3940 } 3941 return nil 3942} 3943 3944func awsRestxml_serializeDocumentListWithNamespace(v []string, value smithyxml.Value) error { 3945 var array *smithyxml.Array 3946 if !value.IsFlattened() { 3947 defer value.Close() 3948 } 3949 array = value.Array() 3950 for i := range v { 3951 am := array.Member() 3952 am.String(v[i]) 3953 } 3954 return nil 3955} 3956 3957func awsRestxml_serializeDocumentNestedPayload(v *types.NestedPayload, value smithyxml.Value) error { 3958 defer value.Close() 3959 if v.Greeting != nil { 3960 rootAttr := []smithyxml.Attr{} 3961 root := smithyxml.StartElement{ 3962 Name: smithyxml.Name{ 3963 Local: "greeting", 3964 }, 3965 Attr: rootAttr, 3966 } 3967 el := value.MemberElement(root) 3968 el.String(*v.Greeting) 3969 } 3970 if v.Name != nil { 3971 rootAttr := []smithyxml.Attr{} 3972 root := smithyxml.StartElement{ 3973 Name: smithyxml.Name{ 3974 Local: "name", 3975 }, 3976 Attr: rootAttr, 3977 } 3978 el := value.MemberElement(root) 3979 el.String(*v.Name) 3980 } 3981 return nil 3982} 3983 3984func awsRestxml_serializeDocumentPayloadWithXmlName(v *types.PayloadWithXmlName, value smithyxml.Value) error { 3985 defer value.Close() 3986 if v.Name != nil { 3987 rootAttr := []smithyxml.Attr{} 3988 root := smithyxml.StartElement{ 3989 Name: smithyxml.Name{ 3990 Local: "name", 3991 }, 3992 Attr: rootAttr, 3993 } 3994 el := value.MemberElement(root) 3995 el.String(*v.Name) 3996 } 3997 return nil 3998} 3999 4000func awsRestxml_serializeDocumentPayloadWithXmlNamespace(v *types.PayloadWithXmlNamespace, value smithyxml.Value) error { 4001 defer value.Close() 4002 if v.Name != nil { 4003 rootAttr := []smithyxml.Attr{} 4004 root := smithyxml.StartElement{ 4005 Name: smithyxml.Name{ 4006 Local: "name", 4007 }, 4008 Attr: rootAttr, 4009 } 4010 el := value.MemberElement(root) 4011 el.String(*v.Name) 4012 } 4013 return nil 4014} 4015 4016func awsRestxml_serializeDocumentPayloadWithXmlNamespaceAndPrefix(v *types.PayloadWithXmlNamespaceAndPrefix, value smithyxml.Value) error { 4017 defer value.Close() 4018 if v.Name != nil { 4019 rootAttr := []smithyxml.Attr{} 4020 root := smithyxml.StartElement{ 4021 Name: smithyxml.Name{ 4022 Local: "name", 4023 }, 4024 Attr: rootAttr, 4025 } 4026 el := value.MemberElement(root) 4027 el.String(*v.Name) 4028 } 4029 return nil 4030} 4031 4032func awsRestxml_serializeDocumentRecursiveShapesInputOutputNested1(v *types.RecursiveShapesInputOutputNested1, value smithyxml.Value) error { 4033 defer value.Close() 4034 if v.Foo != nil { 4035 rootAttr := []smithyxml.Attr{} 4036 root := smithyxml.StartElement{ 4037 Name: smithyxml.Name{ 4038 Local: "foo", 4039 }, 4040 Attr: rootAttr, 4041 } 4042 el := value.MemberElement(root) 4043 el.String(*v.Foo) 4044 } 4045 if v.Nested != nil { 4046 rootAttr := []smithyxml.Attr{} 4047 root := smithyxml.StartElement{ 4048 Name: smithyxml.Name{ 4049 Local: "nested", 4050 }, 4051 Attr: rootAttr, 4052 } 4053 el := value.MemberElement(root) 4054 if err := awsRestxml_serializeDocumentRecursiveShapesInputOutputNested2(v.Nested, el); err != nil { 4055 return err 4056 } 4057 } 4058 return nil 4059} 4060 4061func awsRestxml_serializeDocumentRecursiveShapesInputOutputNested2(v *types.RecursiveShapesInputOutputNested2, value smithyxml.Value) error { 4062 defer value.Close() 4063 if v.Bar != nil { 4064 rootAttr := []smithyxml.Attr{} 4065 root := smithyxml.StartElement{ 4066 Name: smithyxml.Name{ 4067 Local: "bar", 4068 }, 4069 Attr: rootAttr, 4070 } 4071 el := value.MemberElement(root) 4072 el.String(*v.Bar) 4073 } 4074 if v.RecursiveMember != nil { 4075 rootAttr := []smithyxml.Attr{} 4076 root := smithyxml.StartElement{ 4077 Name: smithyxml.Name{ 4078 Local: "recursiveMember", 4079 }, 4080 Attr: rootAttr, 4081 } 4082 el := value.MemberElement(root) 4083 if err := awsRestxml_serializeDocumentRecursiveShapesInputOutputNested1(v.RecursiveMember, el); err != nil { 4084 return err 4085 } 4086 } 4087 return nil 4088} 4089 4090func awsRestxml_serializeDocumentRenamedListMembers(v []string, value smithyxml.Value) error { 4091 var array *smithyxml.Array 4092 if !value.IsFlattened() { 4093 defer value.Close() 4094 } 4095 customMemberNameAttr := []smithyxml.Attr{} 4096 customMemberName := smithyxml.StartElement{ 4097 Name: smithyxml.Name{ 4098 Local: "item", 4099 }, 4100 Attr: customMemberNameAttr, 4101 } 4102 array = value.ArrayWithCustomName(customMemberName) 4103 for i := range v { 4104 am := array.Member() 4105 am.String(v[i]) 4106 } 4107 return nil 4108} 4109 4110func awsRestxml_serializeDocumentStructureList(v []types.StructureListMember, value smithyxml.Value) error { 4111 var array *smithyxml.Array 4112 if !value.IsFlattened() { 4113 defer value.Close() 4114 } 4115 customMemberNameAttr := []smithyxml.Attr{} 4116 customMemberName := smithyxml.StartElement{ 4117 Name: smithyxml.Name{ 4118 Local: "item", 4119 }, 4120 Attr: customMemberNameAttr, 4121 } 4122 array = value.ArrayWithCustomName(customMemberName) 4123 for i := range v { 4124 am := array.Member() 4125 if err := awsRestxml_serializeDocumentStructureListMember(&v[i], am); err != nil { 4126 return err 4127 } 4128 } 4129 return nil 4130} 4131 4132func awsRestxml_serializeDocumentStructureListMember(v *types.StructureListMember, value smithyxml.Value) error { 4133 defer value.Close() 4134 if v.A != nil { 4135 rootAttr := []smithyxml.Attr{} 4136 root := smithyxml.StartElement{ 4137 Name: smithyxml.Name{ 4138 Local: "value", 4139 }, 4140 Attr: rootAttr, 4141 } 4142 el := value.MemberElement(root) 4143 el.String(*v.A) 4144 } 4145 if v.B != nil { 4146 rootAttr := []smithyxml.Attr{} 4147 root := smithyxml.StartElement{ 4148 Name: smithyxml.Name{ 4149 Local: "other", 4150 }, 4151 Attr: rootAttr, 4152 } 4153 el := value.MemberElement(root) 4154 el.String(*v.B) 4155 } 4156 return nil 4157} 4158 4159func awsRestxml_serializeDocumentXmlAttributesInputOutput(v *types.XmlAttributesInputOutput, value smithyxml.Value) error { 4160 defer value.Close() 4161 if v.Foo != nil { 4162 rootAttr := []smithyxml.Attr{} 4163 root := smithyxml.StartElement{ 4164 Name: smithyxml.Name{ 4165 Local: "foo", 4166 }, 4167 Attr: rootAttr, 4168 } 4169 el := value.MemberElement(root) 4170 el.String(*v.Foo) 4171 } 4172 return nil 4173} 4174 4175func awsRestxml_serializeDocumentXmlMapsInputOutputMap(v map[string]types.GreetingStruct, value smithyxml.Value) error { 4176 if !value.IsFlattened() { 4177 defer value.Close() 4178 } 4179 m := value.Map() 4180 for key := range v { 4181 entry := m.Entry() 4182 keyElementAttr := []smithyxml.Attr{} 4183 keyElement := smithyxml.StartElement{ 4184 Name: smithyxml.Name{ 4185 Local: "key", 4186 }, 4187 Attr: keyElementAttr, 4188 } 4189 entry.MemberElement(keyElement).String(key) 4190 valueElementAttr := []smithyxml.Attr{} 4191 valueElement := smithyxml.StartElement{ 4192 Name: smithyxml.Name{ 4193 Local: "value", 4194 }, 4195 Attr: valueElementAttr, 4196 } 4197 mapVar := v[key] 4198 if err := awsRestxml_serializeDocumentGreetingStruct(&mapVar, entry.MemberElement(valueElement)); err != nil { 4199 return err 4200 } 4201 entry.Close() 4202 } 4203 return nil 4204} 4205 4206func awsRestxml_serializeDocumentXmlMapsXmlNameInputOutputMap(v map[string]types.GreetingStruct, value smithyxml.Value) error { 4207 if !value.IsFlattened() { 4208 defer value.Close() 4209 } 4210 m := value.Map() 4211 for key := range v { 4212 entry := m.Entry() 4213 keyElementAttr := []smithyxml.Attr{} 4214 keyElement := smithyxml.StartElement{ 4215 Name: smithyxml.Name{ 4216 Local: "Attribute", 4217 }, 4218 Attr: keyElementAttr, 4219 } 4220 entry.MemberElement(keyElement).String(key) 4221 valueElementAttr := []smithyxml.Attr{} 4222 valueElement := smithyxml.StartElement{ 4223 Name: smithyxml.Name{ 4224 Local: "Setting", 4225 }, 4226 Attr: valueElementAttr, 4227 } 4228 mapVar := v[key] 4229 if err := awsRestxml_serializeDocumentGreetingStruct(&mapVar, entry.MemberElement(valueElement)); err != nil { 4230 return err 4231 } 4232 entry.Close() 4233 } 4234 return nil 4235} 4236 4237func awsRestxml_serializeDocumentXmlNamespacedList(v []string, value smithyxml.Value) error { 4238 var array *smithyxml.Array 4239 if !value.IsFlattened() { 4240 defer value.Close() 4241 } 4242 customMemberNameAttr := []smithyxml.Attr{} 4243 customMemberNameAttr = append(customMemberNameAttr, smithyxml.NewNamespaceAttribute("", "http://bux.com")) 4244 customMemberName := smithyxml.StartElement{ 4245 Name: smithyxml.Name{ 4246 Local: "member", 4247 }, 4248 Attr: customMemberNameAttr, 4249 } 4250 array = value.ArrayWithCustomName(customMemberName) 4251 for i := range v { 4252 am := array.Member() 4253 am.String(v[i]) 4254 } 4255 return nil 4256} 4257 4258func awsRestxml_serializeDocumentXmlNamespaceNested(v *types.XmlNamespaceNested, value smithyxml.Value) error { 4259 defer value.Close() 4260 if v.Foo != nil { 4261 rootAttr := []smithyxml.Attr{} 4262 rootAttr = append(rootAttr, smithyxml.NewNamespaceAttribute("baz", "http://baz.com")) 4263 root := smithyxml.StartElement{ 4264 Name: smithyxml.Name{ 4265 Local: "foo", 4266 }, 4267 Attr: rootAttr, 4268 } 4269 el := value.MemberElement(root) 4270 el.String(*v.Foo) 4271 } 4272 if v.Values != nil { 4273 rootAttr := []smithyxml.Attr{} 4274 rootAttr = append(rootAttr, smithyxml.NewNamespaceAttribute("", "http://qux.com")) 4275 root := smithyxml.StartElement{ 4276 Name: smithyxml.Name{ 4277 Local: "values", 4278 }, 4279 Attr: rootAttr, 4280 } 4281 el := value.MemberElement(root) 4282 if err := awsRestxml_serializeDocumentXmlNamespacedList(v.Values, el); err != nil { 4283 return err 4284 } 4285 } 4286 return nil 4287} 4288 4289func awsRestxml_serializeDocumentBooleanList(v []bool, value smithyxml.Value) error { 4290 var array *smithyxml.Array 4291 if !value.IsFlattened() { 4292 defer value.Close() 4293 } 4294 array = value.Array() 4295 for i := range v { 4296 am := array.Member() 4297 am.Boolean(v[i]) 4298 } 4299 return nil 4300} 4301 4302func awsRestxml_serializeDocumentFooEnumList(v []types.FooEnum, value smithyxml.Value) error { 4303 var array *smithyxml.Array 4304 if !value.IsFlattened() { 4305 defer value.Close() 4306 } 4307 array = value.Array() 4308 for i := range v { 4309 am := array.Member() 4310 am.String(string(v[i])) 4311 } 4312 return nil 4313} 4314 4315func awsRestxml_serializeDocumentFooEnumMap(v map[string]types.FooEnum, value smithyxml.Value) error { 4316 if !value.IsFlattened() { 4317 defer value.Close() 4318 } 4319 m := value.Map() 4320 for key := range v { 4321 entry := m.Entry() 4322 keyElementAttr := []smithyxml.Attr{} 4323 keyElement := smithyxml.StartElement{ 4324 Name: smithyxml.Name{ 4325 Local: "key", 4326 }, 4327 Attr: keyElementAttr, 4328 } 4329 entry.MemberElement(keyElement).String(key) 4330 valueElementAttr := []smithyxml.Attr{} 4331 valueElement := smithyxml.StartElement{ 4332 Name: smithyxml.Name{ 4333 Local: "value", 4334 }, 4335 Attr: valueElementAttr, 4336 } 4337 entry.MemberElement(valueElement).String(string(v[key])) 4338 entry.Close() 4339 } 4340 return nil 4341} 4342 4343func awsRestxml_serializeDocumentFooEnumSet(v []types.FooEnum, value smithyxml.Value) error { 4344 var array *smithyxml.Array 4345 if !value.IsFlattened() { 4346 defer value.Close() 4347 } 4348 array = value.Array() 4349 for i := range v { 4350 am := array.Member() 4351 am.String(string(v[i])) 4352 } 4353 return nil 4354} 4355 4356func awsRestxml_serializeDocumentGreetingStruct(v *types.GreetingStruct, value smithyxml.Value) error { 4357 defer value.Close() 4358 if v.Hi != nil { 4359 rootAttr := []smithyxml.Attr{} 4360 root := smithyxml.StartElement{ 4361 Name: smithyxml.Name{ 4362 Local: "hi", 4363 }, 4364 Attr: rootAttr, 4365 } 4366 el := value.MemberElement(root) 4367 el.String(*v.Hi) 4368 } 4369 return nil 4370} 4371 4372func awsRestxml_serializeDocumentIntegerList(v []int32, value smithyxml.Value) error { 4373 var array *smithyxml.Array 4374 if !value.IsFlattened() { 4375 defer value.Close() 4376 } 4377 array = value.Array() 4378 for i := range v { 4379 am := array.Member() 4380 am.Integer(v[i]) 4381 } 4382 return nil 4383} 4384 4385func awsRestxml_serializeDocumentNestedStringList(v [][]string, value smithyxml.Value) error { 4386 var array *smithyxml.Array 4387 if !value.IsFlattened() { 4388 defer value.Close() 4389 } 4390 array = value.Array() 4391 for i := range v { 4392 if v[i] == nil { 4393 am := array.Member() 4394 am.Close() 4395 continue 4396 } 4397 am := array.Member() 4398 if err := awsRestxml_serializeDocumentStringList(v[i], am); err != nil { 4399 return err 4400 } 4401 } 4402 return nil 4403} 4404 4405func awsRestxml_serializeDocumentStringList(v []string, value smithyxml.Value) error { 4406 var array *smithyxml.Array 4407 if !value.IsFlattened() { 4408 defer value.Close() 4409 } 4410 array = value.Array() 4411 for i := range v { 4412 am := array.Member() 4413 am.String(v[i]) 4414 } 4415 return nil 4416} 4417 4418func awsRestxml_serializeDocumentStringSet(v []string, value smithyxml.Value) error { 4419 var array *smithyxml.Array 4420 if !value.IsFlattened() { 4421 defer value.Close() 4422 } 4423 array = value.Array() 4424 for i := range v { 4425 am := array.Member() 4426 am.String(v[i]) 4427 } 4428 return nil 4429} 4430 4431func awsRestxml_serializeDocumentTimestampList(v []time.Time, value smithyxml.Value) error { 4432 var array *smithyxml.Array 4433 if !value.IsFlattened() { 4434 defer value.Close() 4435 } 4436 array = value.Array() 4437 for i := range v { 4438 am := array.Member() 4439 am.String(smithytime.FormatDateTime(v[i])) 4440 } 4441 return nil 4442} 4443