serde.go

package smithy

import (
	"fmt"
	"io"
	"math/big"
	"time"

	"github.com/aws/smithy-go/document"
)

// ShapeSerializer implements the marshaling of an in-code representation of a
// shape to an unspecified data format, which is determined by the
// implementation.
//
// A ShapeSerializer is consumed by the **code-generated** Serialize() method
// of a modeled structure. For example:
//
//	func (v *PutItemInput) Serialize(s smithy.ShapeSerializer) {
//		s.WriteStruct(schemas.PutItemInput)
//		v.SerializeMembers(s)
//		s.CloseStruct()
//	}
//
//	func (v *PutItemInput) SerializeMembers(s smithy.ShapeSerializer) {
//		if v.TableName != nil {
//			s.WriteString(schemas.PutItemInput_TableName, *v.TableName)
//		}
//		if v.Item != nil {
//			serializeAttributeMap(s, schemas.PutItemInput_Item, v.Item)
//		}
//		// ...
//	}
type ShapeSerializer interface {
	Bytes() []byte

	WriteInt8(*Schema, int8)
	WriteInt16(*Schema, int16)
	WriteInt32(*Schema, int32)
	WriteInt64(*Schema, int64)
	WriteFloat32(*Schema, float32)
	WriteFloat64(*Schema, float64)
	WriteBool(*Schema, bool)
	WriteString(*Schema, string)
	WriteBigInt(*Schema, *big.Int)
	WriteBigFloat(*Schema, *big.Float)
	WriteBlob(*Schema, []byte)
	WriteTime(*Schema, time.Time)

	WriteUnion(schema, variant *Schema)
	CloseUnion()
	WriteDocument(*Schema, document.Value)
	WriteNil(*Schema)

	WriteStruct(*Schema)
	CloseStruct()

	WriteList(*Schema)
	CloseList()

	WriteMap(*Schema)
	WriteKey(*Schema, string)
	CloseMap()
}

// ShapeDeserializer implements the unmarshaling from some unspecified data
// format to an in-code representation of a shape, which is determined by the
// implementation.
type ShapeDeserializer interface {
	ReadInt8(*Schema, *int8) error
	ReadInt16(*Schema, *int16) error
	ReadInt32(*Schema, *int32) error
	ReadInt64(*Schema, *int64) error
	ReadFloat32(*Schema, *float32) error
	ReadFloat64(*Schema, *float64) error
	ReadBool(*Schema, *bool) error
	ReadString(*Schema, *string) error
	ReadBlob(*Schema, *[]byte) error
	ReadTime(*Schema, *time.Time) error
	ReadBigInt(*Schema, *big.Int) error
	ReadBigFloat(*Schema, *big.Float) error
	ReadNil(*Schema) (bool, error)

	ReadStruct(*Schema) error
	ReadStructMember() (*Schema, error)

	ReadUnion(*Schema) (*Schema, error)
	ReadDocument(*Schema, *document.Value) error

	ReadList(*Schema) error
	ReadListItem(*Schema) (hasMoreElements bool, err error)

	ReadMap(*Schema) error
	ReadMapKey(*Schema) (key string, hasMoreElements bool, err error)
}

// Serializable is an entity that can describe itself to a ShapeSerializer to
// be encoded to some format.
//
// Unlike the standard library marshaler interfaces, which idiomatically encode
// to []byte, the output format and data type here is not specified at all.
// This is because Smithy shapes need to encode to a variety of formats or data
// carriers. For example, HTTP-binding JSON protocols need to serialize some
// members to bytes (the HTTP request body) and others directly to fields on
// the HTTP request itself (e.g. headers).
type Serializable interface {
	Serialize(ShapeSerializer)
}

// StreamingInput is implemented by input types that have a streaming blob
// payload (an io.Reader member with @httpPayload + @streaming).
type StreamingInput interface {
	GetPayloadStream() io.Reader
}

// StreamingOutput is implemented by output types that have a streaming blob
// payload (an io.ReadCloser member with @httpPayload + @streaming).
type StreamingOutput interface {
	SetPayloadStream(io.ReadCloser)
}

// Deserializable is an entity that can unmarshal itself from a
// ShapeDeserializer.
type Deserializable interface {
	Deserialize(ShapeDeserializer) error
}

// DeserializableError is implemented by modeled error types for a service.
type DeserializableError interface {
	Deserializable
	error
}

// ReadUnion is a utility API for generated clients.
func ReadUnion(d ShapeDeserializer, schema *Schema, memberFn func(*Schema) error) error {
	ms, err := d.ReadUnion(schema)
	if ms == nil || err != nil {
		return err
	}

	if err := memberFn(ms); err != nil {
		return err
	}

	for {
		ms, err = d.ReadUnion(schema)
		if err != nil {
			return err
		}
		if ms == nil {
			return nil
		}
		return fmt.Errorf("union has more than one non-nil member: %s", ms.MemberName())
	}
}

// ReadStruct is a utility API for generated clients.
func ReadStruct(d ShapeDeserializer, schema *Schema, memberFn func(*Schema) error) error {
	if err := d.ReadStruct(schema); err != nil {
		return err
	}

	for {
		ms, err := d.ReadStructMember()
		if err != nil {
			return err
		}

		if ms == nil {
			return nil
		}

		if err := memberFn(ms); err != nil {
			return err
		}
	}
}

// ReadList is a utility API for generated clients.
func ReadList(d ShapeDeserializer, schema *Schema, memberFn func() error) error {
	if err := d.ReadList(schema); err != nil {
		return err
	}

	var memberSchema *Schema
	if schema != nil {
		memberSchema = schema.ListMember()
	}

	for {
		ok, err := d.ReadListItem(memberSchema)
		if !ok {
			return nil
		}
		if err != nil {
			return err
		}

		if err := memberFn(); err != nil {
			return err
		}
	}
}

// ReadMap is a utility API for generated clients.
func ReadMap(d ShapeDeserializer, schema *Schema, memberFn func(string) error) error {
	if err := d.ReadMap(schema); err != nil {
		return err
	}

	var keySchema *Schema
	if schema != nil {
		keySchema = schema.MapKey()
	}

	for {
		k, ok, err := d.ReadMapKey(keySchema)
		if !ok {
			return nil
		}
		if err != nil {
			return err
		}

		if err := memberFn(k); err != nil {
			return err
		}
	}
}