document

type Blob ¶ added in v1.27.0

type Blob []byte

Blob is a document blob value.

type Boolean ¶ added in v1.27.0

type Boolean bool

Boolean is a document boolean value.

type InvalidMarshalError ¶

type InvalidMarshalError struct {
	Message string
}

An InvalidMarshalError is an error type representing an error occurring when marshaling a Go value type.

func (e *InvalidMarshalError) Error() string

type InvalidUnmarshalError ¶

type InvalidUnmarshalError struct {
	Type reflect.Type
}

An InvalidUnmarshalError is an error type representing an invalid type encountered while unmarshaling a Smithy document to a Go value type.

func (e *InvalidUnmarshalError) Error() string

type List ¶ added in v1.27.0

type List []Value

List is a document list value.

type Map ¶ added in v1.27.0

type Map map[string]Value

Map is a document map value with string keys.

type Marshaler ¶

type Marshaler interface {
	MarshalSmithyDocument() ([]byte, error)
}

Marshaler is an interface for a type that marshals a document to its protocol-specific byte representation and returns the resulting bytes. A non-nil error will be returned if an error is encountered during marshaling.

Marshal supports basic scalars (int,uint,float,bool,string), big.Int, and big.Float, maps, slices, and structs. Anonymous nested types are flattened based on Go anonymous type visibility.

When defining struct types. the `document` struct tag can be used to control how the value will be marshaled into the resulting protocol document.

// Field is ignored
Field int `document:"-"`

// Field object of key "myName"
Field int `document:"myName"`

// Field object key of key "myName", and
// Field is omitted if the field is a zero value for the type.
Field int `document:"myName,omitempty"`

// Field object key of "Field", and
// Field is omitted if the field is a zero value for the type.
Field int `document:",omitempty"`

All struct fields, including anonymous fields, are marshaled unless the any of the following conditions are meet.

• the field is not exported
• document field tag is "-"
• document field tag specifies "omitempty", and is a zero value.

Pointer and interface values are encoded as the value pointed to or contained in the interface. A nil value encodes as a null value unless `omitempty` struct tag is provided.

Channel, complex, and function values are not encoded and will be skipped when walking the value to be marshaled.

time.Time is not supported and will cause the Marshaler to return an error. These values should be represented by your application as a string or numerical representation.

Errors that occur when marshaling will stop the marshaler, and return the error.

Marshal cannot represent cyclic data structures and will not handle them. Passing cyclic structures to Marshal will result in an infinite recursion.

Marshaler is not used in schema-serde based services (which are currently being rolled out) since having an implementation of Marshaler locks a document into support for a specific serial format. Existing implementations of Marshaler will continue to encode to JSON as that is effectively the only serial format supported for Document prior to the introduction of schema-serde. In schema-serde services it is replaced by Value.

type NoSerde ¶

type NoSerde struct{}

NoSerde is a sentinel value to indicate that a given type should not be marshaled or unmarshaled into a protocol document.

type Null ¶ added in v1.27.0

type Null struct{}

Null is a document null value.

type Number ¶

type Number string

Number is an arbitrary precision numerical value

func (n Number) BigFloat() (*big.Float, error)

func (n Number) BigInt() (*big.Int, error)

func (n Number) Float32() (float64, error)

func (n Number) Float64() (float64, error)

func (n Number) Int64() (int64, error)

func (n Number) String() string

func (n Number) Uint64() (uint64, error)

type Opaque ¶ added in v1.27.0

type Opaque struct {
	Value any
}

Opaque wraps an arbitrary Go value for backward compatibility with the legacy reflection-based document serialization path.

type String ¶ added in v1.27.0

type String string

String is a document string value.

type Structure ¶ added in v1.27.0

type Structure struct {
	// Discriminator is the absolute shape ID (e.g.
	// "com.example#MyShape") of the concrete type this structure
	// represents. It may be empty if the type is unknown.
	Discriminator string

	// Members maps member names to their document values.
	Members map[string]Value
}

Structure is a document structure value with an optional discriminator identifying the shape it represents.

type Timestamp ¶ added in v1.27.0

type Timestamp time.Time

Timestamp is a document timestamp value.

type UnmarshalError ¶

type UnmarshalError struct {
	Err   error
	Value string
	Type  reflect.Type
}

An UnmarshalError wraps an error that occurred while unmarshaling a Smithy document into a Go type. This is different from UnmarshalTypeError in that it wraps the underlying error that occurred.

func (e *UnmarshalError) Error() string

func (e *UnmarshalError) Unwrap() error

type UnmarshalTypeError ¶

type UnmarshalTypeError struct {
	Value string
	Type  reflect.Type
}

UnmarshalTypeError is an error type representing an error unmarshaling a Smithy document to a Go value type. This is different from UnmarshalError in that it does not wrap an underlying error type.

func (e *UnmarshalTypeError) Error() string

type Unmarshaler ¶

type Unmarshaler interface {
	UnmarshalSmithyDocument(v interface{}) error
}

Unmarshaler is an interface for a type that unmarshals a document from its protocol-specific representation, and stores the result into the value pointed by v. If v is nil or not a pointer then InvalidUnmarshalError will be returned.

Unmarshaler supports the same encodings produced by a document Marshaler. This includes support for the `document` struct field tag for controlling how struct fields are unmarshaled.

Both generic interface{} and concrete types are valid unmarshal destination types. When unmarshaling a document into an empty interface the Unmarshaler will store one of these values:

bool,                   for boolean values
document.Number,        for arbitrary-precision numbers (int64, float64, big.Int, big.Float)
string,                 for string values
[]interface{},          for array values
map[string]interface{}, for objects
nil,                    for null values

When unmarshaling, any error that occurs will halt the unmarshal and return the error.

type Value ¶ added in v1.27.0

type Value interface {
	// contains filtered or unexported methods
}

Value is a sealed type representing a Smithy document value. It covers the full Smithy data model including blob and timestamp.

The following types implement Value:

• Null
• Boolean
• Number
• String
• Blob
• Timestamp
• List
• Map
• Structure
• Opaque