Switch to using the dep tool and update all the dependencies

vendor/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute/encode.go

@@ -0,0 +1,636 @@
+package dynamodbattribute
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+)
+
+// An UnixTime provides aliasing of time.Time into a type that when marshaled
+// and unmarshaled with DynamoDB AttributeValues it will be done so as number
+// instead of string in seconds since January 1, 1970 UTC.
+//
+// This type is useful as an alterntitive to the struct tag `unixtime` when you
+// want to have your time value marshaled as Unix time in seconds intead of
+// the default time.RFC3339.
+//
+// Important to note that zero value time as unixtime is not 0 seconds
+// from January 1, 1970 UTC, but -62135596800. Which is seconds between
+// January 1, 0001 UTC, and January 1, 0001 UTC.
+type UnixTime time.Time
+
+// MarshalDynamoDBAttributeValue implements the Marshaler interface so that
+// the UnixTime can be marshaled from to a DynamoDB AttributeValue number
+// value encoded in the number of seconds since January 1, 1970 UTC.
+func (e UnixTime) MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
+	t := time.Time(e)
+	s := strconv.FormatInt(t.Unix(), 10)
+	av.N = &s
+
+	return nil
+}
+
+// UnmarshalDynamoDBAttributeValue implements the Unmarshaler interface so that
+// the UnixTime can be unmarshaled from a DynamoDB AttributeValue number representing
+// the number of seconds since January 1, 1970 UTC.
+//
+// If an error parsing the AttributeValue number occurs UnmarshalError will be
+// returned.
+func (e *UnixTime) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
+	t, err := decodeUnixTime(aws.StringValue(av.N))
+	if err != nil {
+		return err
+	}
+
+	*e = UnixTime(t)
+	return nil
+}
+
+// A Marshaler is an interface to provide custom marshaling of Go value types
+// to AttributeValues. Use this to provide custom logic determining how a
+// Go Value type should be marshaled.
+//
+//		type ExampleMarshaler struct {
+//			Value int
+//		}
+//		func (m *ExampleMarshaler) 	MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
+//			n := fmt.Sprintf("%v", m.Value)
+//			av.N = &n
+//			return nil
+//		}
+//
+type Marshaler interface {
+	MarshalDynamoDBAttributeValue(*dynamodb.AttributeValue) error
+}
+
+// Marshal will serialize the passed in Go value type into a DynamoDB AttributeValue
+// type. This value can be used in DynamoDB API operations to simplify marshaling
+// your Go value types into AttributeValues.
+//
+// Marshal will recursively transverse the passed in value marshaling its
+// contents into a AttributeValue. Marshal supports basic scalars
+// (int,uint,float,bool,string), maps, slices, and structs. Anonymous
+// nested types are flattened based on Go anonymous type visibility.
+//
+// Marshaling slices to AttributeValue will default to a List for all
+// types except for []byte and [][]byte. []byte will be marshaled as
+// Binary data (B), and [][]byte will be marshaled as binary data set
+// (BS).
+//
+// `dynamodbav` struct tag can be used to control how the value will be
+// marshaled into a AttributeValue.
+//
+//		// Field is ignored
+//		Field int `dynamodbav:"-"`
+//
+//		// Field AttributeValue map key "myName"
+//		Field int `dynamodbav:"myName"`
+//
+//		// Field AttributeValue map key "myName", and
+//		// Field is omitted if it is empty
+//		Field int `dynamodbav:"myName,omitempty"`
+//
+//		// Field AttributeValue map key "Field", and
+//		// Field is omitted if it is empty
+//		Field int `dynamodbav:",omitempty"`
+//
+//		// Field's elems will be omitted if empty
+//		// only valid for slices, and maps.
+//		Field []string `dynamodbav:",omitemptyelem"`
+//
+//		// Field will be marshaled as a AttributeValue string
+//		// only value for number types, (int,uint,float)
+//		Field int `dynamodbav:",string"`
+//
+//		// Field will be marshaled as a binary set
+//		Field [][]byte `dynamodbav:",binaryset"`
+//
+//		// Field will be marshaled as a number set
+//		Field []int `dynamodbav:",numberset"`
+//
+//		// Field will be marshaled as a string set
+//		Field []string `dynamodbav:",stringset"`
+//
+//		// Field will be marshaled as Unix time number in seconds.
+//		// This tag is only valid with time.Time typed struct fields.
+//		// Important to note that zero value time as unixtime is not 0 seconds
+//		// from January 1, 1970 UTC, but -62135596800. Which is seconds between
+//		// January 1, 0001 UTC, and January 1, 0001 UTC.
+//		Field time.Time `dynamodbav:",unixtime"`
+//
+// The omitempty tag is only used during Marshaling and is ignored for
+// Unmarshal. Any zero value or a value when marshaled results in a
+// AttributeValue NULL will be added to AttributeValue Maps during struct
+// marshal. The omitemptyelem tag works the same as omitempty except it
+// applies to maps and slices instead of struct fields, and will not be
+// included in the marshaled AttributeValue Map, List, or Set.
+//
+// For convenience and backwards compatibility with ConvertTo functions
+// json struct tags are supported by the Marshal and Unmarshal. If
+// both json and dynamodbav struct tags are provided the json tag will
+// be ignored in favor of dynamodbav.
+//
+// All struct fields and with anonymous fields, are marshaled unless the
+// any of the following conditions are meet.
+//
+//		- the field is not exported
+//		- json or dynamodbav field tag is "-"
+//		- json or dynamodbav field tag specifies "omitempty", and is empty.
+//
+// Pointer and interfaces values encode as the value pointed to or contained
+// in the interface. A nil value encodes as the AttributeValue NULL value.
+//
+// Channel, complex, and function values are not encoded and will be skipped
+// when walking the value to be marshaled.
+//
+// When marshaling any error that occurs will halt the marshal 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.
+func Marshal(in interface{}) (*dynamodb.AttributeValue, error) {
+	return NewEncoder().Encode(in)
+}
+
+// MarshalMap is an alias for Marshal func which marshals Go value
+// type to a map of AttributeValues.
+//
+// This is useful for DynamoDB APIs such as PutItem.
+func MarshalMap(in interface{}) (map[string]*dynamodb.AttributeValue, error) {
+	av, err := NewEncoder().Encode(in)
+	if err != nil || av == nil || av.M == nil {
+		return map[string]*dynamodb.AttributeValue{}, err
+	}
+
+	return av.M, nil
+}
+
+// MarshalList is an alias for Marshal func which marshals Go value
+// type to a slice of AttributeValues.
+func MarshalList(in interface{}) ([]*dynamodb.AttributeValue, error) {
+	av, err := NewEncoder().Encode(in)
+	if err != nil || av == nil || av.L == nil {
+		return []*dynamodb.AttributeValue{}, err
+	}
+
+	return av.L, nil
+}
+
+// A MarshalOptions is a collection of options shared between marshaling
+// and unmarshaling
+type MarshalOptions struct {
+	// States that the encoding/json struct tags should be supported.
+	// if a `dynamodbav` struct tag is also provided the encoding/json
+	// tag will be ignored.
+	//
+	// Enabled by default.
+	SupportJSONTags bool
+}
+
+// An Encoder provides marshaling Go value types to AttributeValues.
+type Encoder struct {
+	MarshalOptions
+
+	// Empty strings, "", will be marked as NULL AttributeValue types.
+	// Empty strings are not valid values for DynamoDB. Will not apply
+	// to lists, sets, or maps. Use the struct tag `omitemptyelem`
+	// to skip empty (zero) values in lists, sets and maps.
+	//
+	// Enabled by default.
+	NullEmptyString bool
+}
+
+// NewEncoder creates a new Encoder with default configuration. Use
+// the `opts` functional options to override the default configuration.
+func NewEncoder(opts ...func(*Encoder)) *Encoder {
+	e := &Encoder{
+		MarshalOptions: MarshalOptions{
+			SupportJSONTags: true,
+		},
+		NullEmptyString: true,
+	}
+	for _, o := range opts {
+		o(e)
+	}
+
+	return e
+}
+
+// Encode will marshal a Go value type to an AttributeValue. Returning
+// the AttributeValue constructed or error.
+func (e *Encoder) Encode(in interface{}) (*dynamodb.AttributeValue, error) {
+	av := &dynamodb.AttributeValue{}
+	if err := e.encode(av, reflect.ValueOf(in), tag{}); err != nil {
+		return nil, err
+	}
+
+	return av, nil
+}
+
+func fieldByIndex(v reflect.Value, index []int,
+	OnEmbeddedNilStruct func(*reflect.Value) bool) reflect.Value {
+	fv := v
+	for i, x := range index {
+		if i > 0 {
+			if fv.Kind() == reflect.Ptr && fv.Type().Elem().Kind() == reflect.Struct {
+				if fv.IsNil() && !OnEmbeddedNilStruct(&fv) {
+					break
+				}
+				fv = fv.Elem()
+			}
+		}
+		fv = fv.Field(x)
+	}
+	return fv
+}
+
+func (e *Encoder) encode(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
+	// We should check for omitted values first before dereferencing.
+	if fieldTag.OmitEmpty && emptyValue(v) {
+		encodeNull(av)
+		return nil
+	}
+
+	// Handle both pointers and interface conversion into types
+	v = valueElem(v)
+
+	if v.Kind() != reflect.Invalid {
+		if used, err := tryMarshaler(av, v); used {
+			return err
+		}
+	}
+
+	switch v.Kind() {
+	case reflect.Invalid:
+		encodeNull(av)
+	case reflect.Struct:
+		return e.encodeStruct(av, v, fieldTag)
+	case reflect.Map:
+		return e.encodeMap(av, v, fieldTag)
+	case reflect.Slice, reflect.Array:
+		return e.encodeSlice(av, v, fieldTag)
+	case reflect.Chan, reflect.Func, reflect.UnsafePointer:
+		// do nothing for unsupported types
+	default:
+		return e.encodeScalar(av, v, fieldTag)
+	}
+
+	return nil
+}
+
+func (e *Encoder) encodeStruct(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
+	// To maintain backwards compatibility with ConvertTo family of methods which
+	// converted time.Time structs to strings
+	if t, ok := v.Interface().(time.Time); ok {
+		if fieldTag.AsUnixTime {
+			return UnixTime(t).MarshalDynamoDBAttributeValue(av)
+		}
+		s := t.Format(time.RFC3339Nano)
+		av.S = &s
+		return nil
+	}
+
+	av.M = map[string]*dynamodb.AttributeValue{}
+	fields := unionStructFields(v.Type(), e.MarshalOptions)
+	for _, f := range fields {
+		if f.Name == "" {
+			return &InvalidMarshalError{msg: "map key cannot be empty"}
+		}
+
+		found := true
+		fv := fieldByIndex(v, f.Index, func(v *reflect.Value) bool {
+			found = false
+			return false // to break the loop.
+		})
+		if !found {
+			continue
+		}
+		elem := &dynamodb.AttributeValue{}
+		err := e.encode(elem, fv, f.tag)
+		if err != nil {
+			return err
+		}
+		skip, err := keepOrOmitEmpty(f.OmitEmpty, elem, err)
+		if err != nil {
+			return err
+		} else if skip {
+			continue
+		}
+
+		av.M[f.Name] = elem
+	}
+	if len(av.M) == 0 {
+		encodeNull(av)
+	}
+
+	return nil
+}
+
+func (e *Encoder) encodeMap(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
+	av.M = map[string]*dynamodb.AttributeValue{}
+	for _, key := range v.MapKeys() {
+		keyName := fmt.Sprint(key.Interface())
+		if keyName == "" {
+			return &InvalidMarshalError{msg: "map key cannot be empty"}
+		}
+
+		elemVal := v.MapIndex(key)
+		elem := &dynamodb.AttributeValue{}
+		err := e.encode(elem, elemVal, tag{})
+		skip, err := keepOrOmitEmpty(fieldTag.OmitEmptyElem, elem, err)
+		if err != nil {
+			return err
+		} else if skip {
+			continue
+		}
+
+		av.M[keyName] = elem
+	}
+	if len(av.M) == 0 {
+		encodeNull(av)
+	}
+
+	return nil
+}
+
+func (e *Encoder) encodeSlice(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
+	switch v.Type().Elem().Kind() {
+	case reflect.Uint8:
+		b := v.Bytes()
+		if len(b) == 0 {
+			encodeNull(av)
+			return nil
+		}
+		av.B = append([]byte{}, b...)
+	default:
+		var elemFn func(dynamodb.AttributeValue) error
+
+		if fieldTag.AsBinSet || v.Type() == byteSliceSlicetype { // Binary Set
+			av.BS = make([][]byte, 0, v.Len())
+			elemFn = func(elem dynamodb.AttributeValue) error {
+				if elem.B == nil {
+					return &InvalidMarshalError{msg: "binary set must only contain non-nil byte slices"}
+				}
+				av.BS = append(av.BS, elem.B)
+				return nil
+			}
+		} else if fieldTag.AsNumSet { // Number Set
+			av.NS = make([]*string, 0, v.Len())
+			elemFn = func(elem dynamodb.AttributeValue) error {
+				if elem.N == nil {
+					return &InvalidMarshalError{msg: "number set must only contain non-nil string numbers"}
+				}
+				av.NS = append(av.NS, elem.N)
+				return nil
+			}
+		} else if fieldTag.AsStrSet { // String Set
+			av.SS = make([]*string, 0, v.Len())
+			elemFn = func(elem dynamodb.AttributeValue) error {
+				if elem.S == nil {
+					return &InvalidMarshalError{msg: "string set must only contain non-nil strings"}
+				}
+				av.SS = append(av.SS, elem.S)
+				return nil
+			}
+		} else { // List
+			av.L = make([]*dynamodb.AttributeValue, 0, v.Len())
+			elemFn = func(elem dynamodb.AttributeValue) error {
+				av.L = append(av.L, &elem)
+				return nil
+			}
+		}
+
+		if n, err := e.encodeList(v, fieldTag, elemFn); err != nil {
+			return err
+		} else if n == 0 {
+			encodeNull(av)
+		}
+	}
+
+	return nil
+}
+
+func (e *Encoder) encodeList(v reflect.Value, fieldTag tag, elemFn func(dynamodb.AttributeValue) error) (int, error) {
+	count := 0
+	for i := 0; i < v.Len(); i++ {
+		elem := dynamodb.AttributeValue{}
+		err := e.encode(&elem, v.Index(i), tag{OmitEmpty: fieldTag.OmitEmptyElem})
+		skip, err := keepOrOmitEmpty(fieldTag.OmitEmptyElem, &elem, err)
+		if err != nil {
+			return 0, err
+		} else if skip {
+			continue
+		}
+
+		if err := elemFn(elem); err != nil {
+			return 0, err
+		}
+		count++
+	}
+
+	return count, nil
+}
+
+func (e *Encoder) encodeScalar(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
+	if v.Type() == numberType {
+		s := v.String()
+		if fieldTag.AsString {
+			av.S = &s
+		} else {
+			av.N = &s
+		}
+		return nil
+	}
+
+	switch v.Kind() {
+	case reflect.Bool:
+		av.BOOL = new(bool)
+		*av.BOOL = v.Bool()
+	case reflect.String:
+		if err := e.encodeString(av, v); err != nil {
+			return err
+		}
+	default:
+		// Fallback to encoding numbers, will return invalid type if not supported
+		if err := e.encodeNumber(av, v); err != nil {
+			return err
+		}
+		if fieldTag.AsString && av.NULL == nil && av.N != nil {
+			av.S = av.N
+			av.N = nil
+		}
+	}
+
+	return nil
+}
+
+func (e *Encoder) encodeNumber(av *dynamodb.AttributeValue, v reflect.Value) error {
+	if used, err := tryMarshaler(av, v); used {
+		return err
+	}
+
+	var out string
+	switch v.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		out = encodeInt(v.Int())
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		out = encodeUint(v.Uint())
+	case reflect.Float32, reflect.Float64:
+		out = encodeFloat(v.Float())
+	default:
+		return &unsupportedMarshalTypeError{Type: v.Type()}
+	}
+
+	av.N = &out
+
+	return nil
+}
+
+func (e *Encoder) encodeString(av *dynamodb.AttributeValue, v reflect.Value) error {
+	if used, err := tryMarshaler(av, v); used {
+		return err
+	}
+
+	switch v.Kind() {
+	case reflect.String:
+		s := v.String()
+		if len(s) == 0 && e.NullEmptyString {
+			encodeNull(av)
+		} else {
+			av.S = &s
+		}
+	default:
+		return &unsupportedMarshalTypeError{Type: v.Type()}
+	}
+
+	return nil
+}
+
+func encodeInt(i int64) string {
+	return strconv.FormatInt(i, 10)
+}
+func encodeUint(u uint64) string {
+	return strconv.FormatUint(u, 10)
+}
+func encodeFloat(f float64) string {
+	return strconv.FormatFloat(f, 'f', -1, 64)
+}
+func encodeNull(av *dynamodb.AttributeValue) {
+	t := true
+	*av = dynamodb.AttributeValue{NULL: &t}
+}
+
+func valueElem(v reflect.Value) reflect.Value {
+	switch v.Kind() {
+	case reflect.Interface, reflect.Ptr:
+		for v.Kind() == reflect.Interface || v.Kind() == reflect.Ptr {
+			v = v.Elem()
+		}
+	}
+
+	return v
+}
+
+func emptyValue(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Interface, reflect.Ptr:
+		return v.IsNil()
+	}
+	return false
+}
+
+func tryMarshaler(av *dynamodb.AttributeValue, v reflect.Value) (bool, error) {
+	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
+		v = v.Addr()
+	}
+
+	if v.Type().NumMethod() == 0 {
+		return false, nil
+	}
+
+	if m, ok := v.Interface().(Marshaler); ok {
+		return true, m.MarshalDynamoDBAttributeValue(av)
+	}
+
+	return false, nil
+}
+
+func keepOrOmitEmpty(omitEmpty bool, av *dynamodb.AttributeValue, err error) (bool, error) {
+	if err != nil {
+		if _, ok := err.(*unsupportedMarshalTypeError); ok {
+			return true, nil
+		}
+		return false, err
+	}
+
+	if av.NULL != nil && omitEmpty {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// An InvalidMarshalError is an error type representing an error
+// occurring when marshaling a Go value type to an AttributeValue.
+type InvalidMarshalError struct {
+	emptyOrigError
+	msg string
+}
+
+// Error returns the string representation of the error.
+// satisfying the error interface
+func (e *InvalidMarshalError) Error() string {
+	return fmt.Sprintf("%s: %s", e.Code(), e.Message())
+}
+
+// Code returns the code of the error, satisfying the awserr.Error
+// interface.
+func (e *InvalidMarshalError) Code() string {
+	return "InvalidMarshalError"
+}
+
+// Message returns the detailed message of the error, satisfying
+// the awserr.Error interface.
+func (e *InvalidMarshalError) Message() string {
+	return e.msg
+}
+
+// An unsupportedMarshalTypeError represents a Go value type
+// which cannot be marshaled into an AttributeValue and should
+// be skipped by the marshaler.
+type unsupportedMarshalTypeError struct {
+	emptyOrigError
+	Type reflect.Type
+}
+
+// Error returns the string representation of the error.
+// satisfying the error interface
+func (e *unsupportedMarshalTypeError) Error() string {
+	return fmt.Sprintf("%s: %s", e.Code(), e.Message())
+}
+
+// Code returns the code of the error, satisfying the awserr.Error
+// interface.
+func (e *unsupportedMarshalTypeError) Code() string {
+	return "unsupportedMarshalTypeError"
+}
+
+// Message returns the detailed message of the error, satisfying
+// the awserr.Error interface.
+func (e *unsupportedMarshalTypeError) Message() string {
+	return "Go value type " + e.Type.String() + " is not supported"
+}