src

header_value.go (10574B)

---

 package eventstream
 
 import (
 	"encoding/base64"
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
 	"io"
 	"strconv"
 	"time"
 )
 
 const maxHeaderValueLen = 1<<15 - 1 // 2^15-1 or 32KB - 1
 
 // valueType is the EventStream header value type.
 type valueType uint8
 
 // Header value types
 const (
 	trueValueType valueType = iota
 	falseValueType
 	int8ValueType  // Byte
 	int16ValueType // Short
 	int32ValueType // Integer
 	int64ValueType // Long
 	bytesValueType
 	stringValueType
 	timestampValueType
 	uuidValueType
 )
 
 func (t valueType) String() string {
 	switch t {
 	case trueValueType:
 		return "bool"
 	case falseValueType:
 		return "bool"
 	case int8ValueType:
 		return "int8"
 	case int16ValueType:
 		return "int16"
 	case int32ValueType:
 		return "int32"
 	case int64ValueType:
 		return "int64"
 	case bytesValueType:
 		return "byte_array"
 	case stringValueType:
 		return "string"
 	case timestampValueType:
 		return "timestamp"
 	case uuidValueType:
 		return "uuid"
 	default:
 		return fmt.Sprintf("unknown value type %d", uint8(t))
 	}
 }
 
 type rawValue struct {
 	Type  valueType
 	Len   uint16 // Only set for variable length slices
 	Value []byte // byte representation of value, BigEndian encoding.
 }
 
 func (r rawValue) encodeScalar(w io.Writer, v any) error {
 	return binaryWriteFields(w, binary.BigEndian,
 		r.Type,
 		v,
 	)
 }
 
 func (r rawValue) encodeFixedSlice(w io.Writer, v []byte) error {
 	binary.Write(w, binary.BigEndian, r.Type)
 
 	_, err := w.Write(v)
 	return err
 }
 
 func (r rawValue) encodeBytes(w io.Writer, v []byte) error {
 	if len(v) > maxHeaderValueLen {
 		return LengthError{
 			Part: "header value",
 			Want: maxHeaderValueLen, Have: len(v),
 			Value: v,
 		}
 	}
 	r.Len = uint16(len(v))
 
 	err := binaryWriteFields(w, binary.BigEndian,
 		r.Type,
 		r.Len,
 	)
 	if err != nil {
 		return err
 	}
 
 	_, err = w.Write(v)
 	return err
 }
 
 func (r rawValue) encodeString(w io.Writer, v string) error {
 	if len(v) > maxHeaderValueLen {
 		return LengthError{
 			Part: "header value",
 			Want: maxHeaderValueLen, Have: len(v),
 			Value: v,
 		}
 	}
 	r.Len = uint16(len(v))
 
 	type stringWriter interface {
 		WriteString(string) (int, error)
 	}
 
 	err := binaryWriteFields(w, binary.BigEndian,
 		r.Type,
 		r.Len,
 	)
 	if err != nil {
 		return err
 	}
 
 	if sw, ok := w.(stringWriter); ok {
 		_, err = sw.WriteString(v)
 	} else {
 		_, err = w.Write([]byte(v))
 	}
 
 	return err
 }
 
 func decodeFixedBytesValue(r io.Reader, buf []byte) error {
 	_, err := io.ReadFull(r, buf)
 	return err
 }
 
 func decodeBytesValue(r io.Reader) ([]byte, error) {
 	var raw rawValue
 	var err error
 	raw.Len, err = decodeUint16(r)
 	if err != nil {
 		return nil, err
 	}
 
 	buf := make([]byte, raw.Len)
 	_, err = io.ReadFull(r, buf)
 	if err != nil {
 		return nil, err
 	}
 
 	return buf, nil
 }
 
 func decodeStringValue(r io.Reader) (string, error) {
 	v, err := decodeBytesValue(r)
 	return string(v), err
 }
 
 // Value represents the abstract header value.
 type Value interface {
 	Get() any
 	String() string
 	valueType() valueType
 	encode(io.Writer) error
 }
 
 // An BoolValue provides eventstream encoding, and representation
 // of a Go bool value.
 type BoolValue bool
 
 // Get returns the underlying type
 func (v BoolValue) Get() any {
 	return bool(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (v BoolValue) valueType() valueType {
 	if v {
 		return trueValueType
 	}
 	return falseValueType
 }
 
 func (v BoolValue) String() string {
 	return strconv.FormatBool(bool(v))
 }
 
 // encode encodes the BoolValue into an eventstream binary value
 // representation.
 func (v BoolValue) encode(w io.Writer) error {
 	return binary.Write(w, binary.BigEndian, v.valueType())
 }
 
 // An Int8Value provides eventstream encoding, and representation of a Go
 // int8 value.
 type Int8Value int8
 
 // Get returns the underlying value.
 func (v Int8Value) Get() any {
 	return int8(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (Int8Value) valueType() valueType {
 	return int8ValueType
 }
 
 func (v Int8Value) String() string {
 	return fmt.Sprintf("0x%02x", int8(v))
 }
 
 // encode encodes the Int8Value into an eventstream binary value
 // representation.
 func (v Int8Value) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 
 	return raw.encodeScalar(w, v)
 }
 
 func (v *Int8Value) decode(r io.Reader) error {
 	n, err := decodeUint8(r)
 	if err != nil {
 		return err
 	}
 
 	*v = Int8Value(n)
 	return nil
 }
 
 // An Int16Value provides eventstream encoding, and representation of a Go
 // int16 value.
 type Int16Value int16
 
 // Get returns the underlying value.
 func (v Int16Value) Get() any {
 	return int16(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (Int16Value) valueType() valueType {
 	return int16ValueType
 }
 
 func (v Int16Value) String() string {
 	return fmt.Sprintf("0x%04x", int16(v))
 }
 
 // encode encodes the Int16Value into an eventstream binary value
 // representation.
 func (v Int16Value) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 	return raw.encodeScalar(w, v)
 }
 
 func (v *Int16Value) decode(r io.Reader) error {
 	n, err := decodeUint16(r)
 	if err != nil {
 		return err
 	}
 
 	*v = Int16Value(n)
 	return nil
 }
 
 // An Int32Value provides eventstream encoding, and representation of a Go
 // int32 value.
 type Int32Value int32
 
 // Get returns the underlying value.
 func (v Int32Value) Get() any {
 	return int32(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (Int32Value) valueType() valueType {
 	return int32ValueType
 }
 
 func (v Int32Value) String() string {
 	return fmt.Sprintf("0x%08x", int32(v))
 }
 
 // encode encodes the Int32Value into an eventstream binary value
 // representation.
 func (v Int32Value) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 	return raw.encodeScalar(w, v)
 }
 
 func (v *Int32Value) decode(r io.Reader) error {
 	n, err := decodeUint32(r)
 	if err != nil {
 		return err
 	}
 
 	*v = Int32Value(n)
 	return nil
 }
 
 // An Int64Value provides eventstream encoding, and representation of a Go
 // int64 value.
 type Int64Value int64
 
 // Get returns the underlying value.
 func (v Int64Value) Get() any {
 	return int64(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (Int64Value) valueType() valueType {
 	return int64ValueType
 }
 
 func (v Int64Value) String() string {
 	return fmt.Sprintf("0x%016x", int64(v))
 }
 
 // encode encodes the Int64Value into an eventstream binary value
 // representation.
 func (v Int64Value) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 	return raw.encodeScalar(w, v)
 }
 
 func (v *Int64Value) decode(r io.Reader) error {
 	n, err := decodeUint64(r)
 	if err != nil {
 		return err
 	}
 
 	*v = Int64Value(n)
 	return nil
 }
 
 // An BytesValue provides eventstream encoding, and representation of a Go
 // byte slice.
 type BytesValue []byte
 
 // Get returns the underlying value.
 func (v BytesValue) Get() any {
 	return []byte(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (BytesValue) valueType() valueType {
 	return bytesValueType
 }
 
 func (v BytesValue) String() string {
 	return base64.StdEncoding.EncodeToString([]byte(v))
 }
 
 // encode encodes the BytesValue into an eventstream binary value
 // representation.
 func (v BytesValue) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 
 	return raw.encodeBytes(w, []byte(v))
 }
 
 func (v *BytesValue) decode(r io.Reader) error {
 	buf, err := decodeBytesValue(r)
 	if err != nil {
 		return err
 	}
 
 	*v = BytesValue(buf)
 	return nil
 }
 
 // An StringValue provides eventstream encoding, and representation of a Go
 // string.
 type StringValue string
 
 // Get returns the underlying value.
 func (v StringValue) Get() any {
 	return string(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (StringValue) valueType() valueType {
 	return stringValueType
 }
 
 func (v StringValue) String() string {
 	return string(v)
 }
 
 // encode encodes the StringValue into an eventstream binary value
 // representation.
 func (v StringValue) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 
 	return raw.encodeString(w, string(v))
 }
 
 func (v *StringValue) decode(r io.Reader) error {
 	s, err := decodeStringValue(r)
 	if err != nil {
 		return err
 	}
 
 	*v = StringValue(s)
 	return nil
 }
 
 // An TimestampValue provides eventstream encoding, and representation of a Go
 // timestamp.
 type TimestampValue time.Time
 
 // Get returns the underlying value.
 func (v TimestampValue) Get() any {
 	return time.Time(v)
 }
 
 // valueType returns the EventStream header value type value.
 func (TimestampValue) valueType() valueType {
 	return timestampValueType
 }
 
 func (v TimestampValue) epochMilli() int64 {
 	nano := time.Time(v).UnixNano()
 	msec := nano / int64(time.Millisecond)
 	return msec
 }
 
 func (v TimestampValue) String() string {
 	msec := v.epochMilli()
 	return strconv.FormatInt(msec, 10)
 }
 
 // encode encodes the TimestampValue into an eventstream binary value
 // representation.
 func (v TimestampValue) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 
 	msec := v.epochMilli()
 	return raw.encodeScalar(w, msec)
 }
 
 func (v *TimestampValue) decode(r io.Reader) error {
 	n, err := decodeUint64(r)
 	if err != nil {
 		return err
 	}
 
 	*v = TimestampValue(timeFromEpochMilli(int64(n)))
 	return nil
 }
 
 // MarshalJSON implements the json.Marshaler interface
 func (v TimestampValue) MarshalJSON() ([]byte, error) {
 	return []byte(v.String()), nil
 }
 
 func timeFromEpochMilli(t int64) time.Time {
 	secs := t / 1e3
 	msec := t % 1e3
 	return time.Unix(secs, msec*int64(time.Millisecond)).UTC()
 }
 
 // An UUIDValue provides eventstream encoding, and representation of a UUID
 // value.
 type UUIDValue [16]byte
 
 // Get returns the underlying value.
 func (v UUIDValue) Get() any {
 	return v[:]
 }
 
 // valueType returns the EventStream header value type value.
 func (UUIDValue) valueType() valueType {
 	return uuidValueType
 }
 
 func (v UUIDValue) String() string {
 	var scratch [36]byte
 
 	const dash = '-'
 
 	hex.Encode(scratch[:8], v[0:4])
 	scratch[8] = dash
 	hex.Encode(scratch[9:13], v[4:6])
 	scratch[13] = dash
 	hex.Encode(scratch[14:18], v[6:8])
 	scratch[18] = dash
 	hex.Encode(scratch[19:23], v[8:10])
 	scratch[23] = dash
 	hex.Encode(scratch[24:], v[10:])
 
 	return string(scratch[:])
 }
 
 // encode encodes the UUIDValue into an eventstream binary value
 // representation.
 func (v UUIDValue) encode(w io.Writer) error {
 	raw := rawValue{
 		Type: v.valueType(),
 	}
 
 	return raw.encodeFixedSlice(w, v[:])
 }
 
 func (v *UUIDValue) decode(r io.Reader) error {
 	tv := (*v)[:]
 	return decodeFixedBytesValue(r, tv)
 }