Involved Source Files
Package document provides interface definitions and error types for document types.
A document is a protocol-agnostic type which supports a JSON-like data-model. You can use this type to send
UTF-8 strings, arbitrary precision numbers, booleans, nulls, a list of these values, and a map of UTF-8
strings to these values.
API Clients expose document constructors in their respective client document packages which must be used to
Marshal and Unmarshal Go types to and from their respective protocol representations.
See the Marshaler and Unmarshaler type documentation for more details on how to Go types can be converted to and from
document types.
document.goerrors.go
Package-Level Type Names (total 9, in which 8 are exported)
/* sort exporteds by: | */
An InvalidMarshalError is an error type representing an error
occurring when marshaling a Go value type.
Messagestring
Error returns the string representation of the error.
Satisfying the error interface.
*InvalidMarshalError : error
An InvalidUnmarshalError is an error type representing an invalid type
encountered while unmarshaling a Smithy document to a Go value type.
Typereflect.Type
Error returns the string representation of the error.
Satisfying the error interface.
*InvalidUnmarshalError : 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) MarshalSmithyDocument() ([]byte, error)
NoSerde is a sentinel value to indicate that a given type should not be marshaled or unmarshaled
into a protocol document.
( NoSerde) noSmithyDocumentSerde()
NoSerde : noSerde
Number is an arbitrary precision numerical value
BigFloat attempts to convert the number to a big.Float, returns an error if the operation fails.
BigInt attempts to convert the number to a big.Int, returns an error if the operation fails.
Float32 returns the number parsed as a 32-bit float, returns a float64.
Float64 returns the number as a float64.
Int64 returns the number as an int64.
Int64 returns the number as a string.
Uint64 returns the number as a uint64.
Float64 returns the number as a float64.
( Number) intOfBitSize(bitSize int) (int64, error)( Number) uintOfBitSize(bitSize int) (uint64, error)
Number : expvar.Var
Number : fmt.Stringer
Number : github.com/aws/smithy-go/middleware.stringer
Number : context.stringer
Number : runtime.stringer
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.
( Unmarshaler) UnmarshalSmithyDocument(v interface{}) error
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.
ErrerrorTypereflect.TypeValuestring
Error returns the string representation of the error.
Satisfying the error interface.
Unwrap returns the underlying unmarshaling error
*UnmarshalError : error
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.
Typereflect.TypeValuestring
Error returns the string representation of the error.
Satisfying the error interface.
*UnmarshalTypeError : error