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