1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package restxmlwithnamespace 4 5import ( 6 "bytes" 7 "context" 8 "encoding/xml" 9 "fmt" 10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" 11 awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml" 12 "github.com/aws/aws-sdk-go-v2/internal/protocoltest/restxmlwithnamespace/types" 13 smithy "github.com/aws/smithy-go" 14 smithyxml "github.com/aws/smithy-go/encoding/xml" 15 smithyio "github.com/aws/smithy-go/io" 16 "github.com/aws/smithy-go/middleware" 17 "github.com/aws/smithy-go/ptr" 18 smithyhttp "github.com/aws/smithy-go/transport/http" 19 "io" 20 "strconv" 21 "strings" 22) 23 24type awsRestxml_deserializeOpSimpleScalarProperties struct { 25} 26 27func (*awsRestxml_deserializeOpSimpleScalarProperties) ID() string { 28 return "OperationDeserializer" 29} 30 31func (m *awsRestxml_deserializeOpSimpleScalarProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 32 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 33) { 34 out, metadata, err = next.HandleDeserialize(ctx, in) 35 if err != nil { 36 return out, metadata, err 37 } 38 39 response, ok := out.RawResponse.(*smithyhttp.Response) 40 if !ok { 41 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 42 } 43 44 if response.StatusCode < 200 || response.StatusCode >= 300 { 45 return out, metadata, awsRestxml_deserializeOpErrorSimpleScalarProperties(response, &metadata) 46 } 47 output := &SimpleScalarPropertiesOutput{} 48 out.Result = output 49 50 err = awsRestxml_deserializeOpHttpBindingsSimpleScalarPropertiesOutput(output, response) 51 if err != nil { 52 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)} 53 } 54 55 var buff [1024]byte 56 ringBuffer := smithyio.NewRingBuffer(buff[:]) 57 body := io.TeeReader(response.Body, ringBuffer) 58 rootDecoder := xml.NewDecoder(body) 59 t, err := smithyxml.FetchRootElement(rootDecoder) 60 if err == io.EOF { 61 return out, metadata, nil 62 } 63 if err != nil { 64 var snapshot bytes.Buffer 65 io.Copy(&snapshot, ringBuffer) 66 return out, metadata, &smithy.DeserializationError{ 67 Err: fmt.Errorf("failed to decode response body, %w", err), 68 Snapshot: snapshot.Bytes(), 69 } 70 } 71 72 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t) 73 err = awsRestxml_deserializeOpDocumentSimpleScalarPropertiesOutput(&output, decoder) 74 if err != nil { 75 var snapshot bytes.Buffer 76 io.Copy(&snapshot, ringBuffer) 77 return out, metadata, &smithy.DeserializationError{ 78 Err: fmt.Errorf("failed to decode response body, %w", err), 79 Snapshot: snapshot.Bytes(), 80 } 81 } 82 83 return out, metadata, err 84} 85 86func awsRestxml_deserializeOpErrorSimpleScalarProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 87 var errorBuffer bytes.Buffer 88 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 89 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 90 } 91 errorBody := bytes.NewReader(errorBuffer.Bytes()) 92 93 errorCode := "UnknownError" 94 errorMessage := errorCode 95 96 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false) 97 if err != nil { 98 return err 99 } 100 if reqID := errorComponents.RequestID; len(reqID) != 0 { 101 awsmiddleware.SetRequestIDMetadata(metadata, reqID) 102 } 103 if len(errorComponents.Code) != 0 { 104 errorCode = errorComponents.Code 105 } 106 if len(errorComponents.Message) != 0 { 107 errorMessage = errorComponents.Message 108 } 109 errorBody.Seek(0, io.SeekStart) 110 switch { 111 default: 112 genericError := &smithy.GenericAPIError{ 113 Code: errorCode, 114 Message: errorMessage, 115 } 116 return genericError 117 118 } 119} 120 121func awsRestxml_deserializeOpHttpBindingsSimpleScalarPropertiesOutput(v *SimpleScalarPropertiesOutput, response *smithyhttp.Response) error { 122 if v == nil { 123 return fmt.Errorf("unsupported deserialization for nil %T", v) 124 } 125 126 if headerValues := response.Header.Values("X-Foo"); len(headerValues) != 0 { 127 headerValues[0] = strings.TrimSpace(headerValues[0]) 128 v.Foo = ptr.String(headerValues[0]) 129 } 130 131 return nil 132} 133func awsRestxml_deserializeOpDocumentSimpleScalarPropertiesOutput(v **SimpleScalarPropertiesOutput, decoder smithyxml.NodeDecoder) error { 134 if v == nil { 135 return fmt.Errorf("unexpected nil of type %T", v) 136 } 137 var sv *SimpleScalarPropertiesOutput 138 if *v == nil { 139 sv = &SimpleScalarPropertiesOutput{} 140 } else { 141 sv = *v 142 } 143 144 for { 145 t, done, err := decoder.Token() 146 if err != nil { 147 return err 148 } 149 if done { 150 break 151 } 152 originalDecoder := decoder 153 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 154 switch { 155 case strings.EqualFold("byteValue", t.Name.Local): 156 val, err := decoder.Value() 157 if err != nil { 158 return err 159 } 160 if val == nil { 161 break 162 } 163 { 164 xtv := string(val) 165 i64, err := strconv.ParseInt(xtv, 10, 64) 166 if err != nil { 167 return err 168 } 169 sv.ByteValue = ptr.Int8(int8(i64)) 170 } 171 172 case strings.EqualFold("DoubleDribble", t.Name.Local): 173 val, err := decoder.Value() 174 if err != nil { 175 return err 176 } 177 if val == nil { 178 break 179 } 180 { 181 xtv := string(val) 182 f64, err := strconv.ParseFloat(xtv, 64) 183 if err != nil { 184 return err 185 } 186 sv.DoubleValue = ptr.Float64(f64) 187 } 188 189 case strings.EqualFold("falseBooleanValue", t.Name.Local): 190 val, err := decoder.Value() 191 if err != nil { 192 return err 193 } 194 if val == nil { 195 break 196 } 197 { 198 xtv, err := strconv.ParseBool(string(val)) 199 if err != nil { 200 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 201 } 202 sv.FalseBooleanValue = ptr.Bool(xtv) 203 } 204 205 case strings.EqualFold("floatValue", t.Name.Local): 206 val, err := decoder.Value() 207 if err != nil { 208 return err 209 } 210 if val == nil { 211 break 212 } 213 { 214 xtv := string(val) 215 f64, err := strconv.ParseFloat(xtv, 64) 216 if err != nil { 217 return err 218 } 219 sv.FloatValue = ptr.Float32(float32(f64)) 220 } 221 222 case strings.EqualFold("integerValue", t.Name.Local): 223 val, err := decoder.Value() 224 if err != nil { 225 return err 226 } 227 if val == nil { 228 break 229 } 230 { 231 xtv := string(val) 232 i64, err := strconv.ParseInt(xtv, 10, 64) 233 if err != nil { 234 return err 235 } 236 sv.IntegerValue = ptr.Int32(int32(i64)) 237 } 238 239 case strings.EqualFold("longValue", t.Name.Local): 240 val, err := decoder.Value() 241 if err != nil { 242 return err 243 } 244 if val == nil { 245 break 246 } 247 { 248 xtv := string(val) 249 i64, err := strconv.ParseInt(xtv, 10, 64) 250 if err != nil { 251 return err 252 } 253 sv.LongValue = ptr.Int64(i64) 254 } 255 256 case strings.EqualFold("Nested", t.Name.Local): 257 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t) 258 if err := awsRestxml_deserializeDocumentNestedWithNamespace(&sv.Nested, nodeDecoder); err != nil { 259 return err 260 } 261 262 case strings.EqualFold("shortValue", t.Name.Local): 263 val, err := decoder.Value() 264 if err != nil { 265 return err 266 } 267 if val == nil { 268 break 269 } 270 { 271 xtv := string(val) 272 i64, err := strconv.ParseInt(xtv, 10, 64) 273 if err != nil { 274 return err 275 } 276 sv.ShortValue = ptr.Int16(int16(i64)) 277 } 278 279 case strings.EqualFold("stringValue", t.Name.Local): 280 val, err := decoder.Value() 281 if err != nil { 282 return err 283 } 284 if val == nil { 285 break 286 } 287 { 288 xtv := string(val) 289 sv.StringValue = ptr.String(xtv) 290 } 291 292 case strings.EqualFold("trueBooleanValue", t.Name.Local): 293 val, err := decoder.Value() 294 if err != nil { 295 return err 296 } 297 if val == nil { 298 break 299 } 300 { 301 xtv, err := strconv.ParseBool(string(val)) 302 if err != nil { 303 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val) 304 } 305 sv.TrueBooleanValue = ptr.Bool(xtv) 306 } 307 308 default: 309 // Do nothing and ignore the unexpected tag element 310 err = decoder.Decoder.Skip() 311 if err != nil { 312 return err 313 } 314 315 } 316 decoder = originalDecoder 317 } 318 *v = sv 319 return nil 320} 321 322func awsRestxml_deserializeDocumentNestedWithNamespace(v **types.NestedWithNamespace, decoder smithyxml.NodeDecoder) error { 323 if v == nil { 324 return fmt.Errorf("unexpected nil of type %T", v) 325 } 326 var sv *types.NestedWithNamespace 327 if *v == nil { 328 sv = &types.NestedWithNamespace{} 329 } else { 330 sv = *v 331 } 332 333 for _, attr := range decoder.StartEl.Attr { 334 name := attr.Name.Local 335 if len(attr.Name.Space) != 0 { 336 name = attr.Name.Space + `:` + attr.Name.Local 337 } 338 switch { 339 case strings.EqualFold("xsi:someName", name): 340 val := []byte(attr.Value) 341 { 342 xtv := string(val) 343 sv.AttrField = ptr.String(xtv) 344 } 345 346 } 347 } 348 for { 349 t, done, err := decoder.Token() 350 if err != nil { 351 return err 352 } 353 if done { 354 break 355 } 356 originalDecoder := decoder 357 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t) 358 switch { 359 default: 360 // Do nothing and ignore the unexpected tag element 361 err = decoder.Decoder.Skip() 362 if err != nil { 363 return err 364 } 365 366 } 367 decoder = originalDecoder 368 } 369 *v = sv 370 return nil 371} 372