codec

type BaseCodec struct {
	// contains filtered or unexported fields
}

type BaseConstraints struct {
	// Name of the field
	Name string
	// Dimension holds the field dimension
	Dimension int
	// Required flag indicating if the field is a required field.
	Required bool
	// TargetNames stores map for known format types. This allows
	TargetNames map[string]string
	// TargetConfig stores configuration that is required by the target format . for Eg. Attribute config for XML etc.
	TargetConfig map[string]string
	// Sequence specifies the order  of the fields in the source/target format
	Sequence int
	//SkipField indicates that if the value of the field is absent/nil then skip the field while writing to data
	//This is similar to omitempty
	SkipField bool
}

type BoolConstraints struct {
	BaseConstraints
	DefaultVal *bool
}

type BytesDecoder interface {
	//DecodeBytes will decode a type from an array of bytes
	DecodeBytes(b []byte, v interface{}) error
}

type BytesEncoder interface {
	// EncodeToBytes will encode the provided type to []byte
	EncodeToBytes(v interface{}) ([]byte, error)
}

type Codec interface {
	Decoder
	Encoder
	ReaderWriter
	//SetOption sets an option to the reader and writer
	SetOption(key string, value interface{})
}

type Decoder interface {
	StringDecoder
	BytesDecoder
}

type Encoder interface {
	StringEncoder
	BytesEncoder
}

type F32Constraints struct {
	BaseConstraints
	DefaultVal *float32
	Min        *float32 //The value is inclusive
	Max        *float32 //The value is inclusive
}

type F64Constraints struct {
	BaseConstraints
	DefaultVal *float64
	Min        *float64 //The value is inclusive
	Max        *float64 //The value is inclusive
}

type IntConstraints struct {
	BaseConstraints
	DefaultVal *int
	Min        *int //The value is inclusive
	Max        *int //The value is inclusive
}

type ReaderWriter interface {
	//Write a type to writer
	Write(v interface{}, w io.Writer) error
	//Read a type from a reader
	Read(r io.Reader, v interface{}) error
	//MimeTypes returns a slice of strings representing the MIME types
	MimeTypes() []string
}

type StrConstraints struct {
	BaseConstraints
	DefaultVal *string
	Pattern    *string
	Format     *string
	MinLength  *int
	MaxLength  *int
}

type StringDecoder interface {
	//DecodeString will decode  a type from string
	DecodeString(s string, v interface{}) error
}

type StringEncoder interface {
	//EncodeToString will encode a type to string
	EncodeToString(v interface{}) (string, error)
}

type StructMeta struct {
	Fields map[string]string
}

type UIntConstraints struct {
	BaseConstraints
	DefaultVal *uint
	Min        *uint //The value is inclusive
	Max        *uint //The value is inclusive
}

type Validator interface {
	Validate() (bool, []error)
}