primitive.go

// Code generated by github.com/actgardner/gogen-avro. DO NOT EDIT.
/*
 * SOURCE:
 *     datapackage.avsc
 */

package avro

import (
	"encoding/binary"
	"fmt"
	"io"
	"math"
)

type ByteWriter interface {
	Grow(int)
	WriteByte(byte) error
}

type StringWriter interface {
	WriteString(string) (int, error)
}

func encodeFloat(w io.Writer, byteCount int, bits uint64) error {
	var err error
	var bb []byte
	bw, ok := w.(ByteWriter)
	if ok {
		bw.Grow(byteCount)
	} else {
		bb = make([]byte, 0, byteCount)
	}
	for i := 0; i < byteCount; i++ {
		if bw != nil {
			err = bw.WriteByte(byte(bits & 255))
			if err != nil {
				return err
			}
		} else {
			bb = append(bb, byte(bits&255))
		}
		bits = bits >> 8
	}
	if bw == nil {
		_, err = w.Write(bb)
		return err
	}
	return nil
}

func encodeInt(w io.Writer, byteCount int, encoded uint64) error {
	var err error
	var bb []byte
	bw, ok := w.(ByteWriter)
	// To avoid reallocations, grow capacity to the largest possible size
	// for this integer
	if ok {
		bw.Grow(byteCount)
	} else {
		bb = make([]byte, 0, byteCount)
	}

	if encoded == 0 {
		if bw != nil {
			err = bw.WriteByte(0)
			if err != nil {
				return err
			}
		} else {
			bb = append(bb, byte(0))
		}
	} else {
		for encoded > 0 {
			b := byte(encoded & 127)
			encoded = encoded >> 7
			if !(encoded == 0) {
				b |= 128
			}
			if bw != nil {
				err = bw.WriteByte(b)
				if err != nil {
					return err
				}
			} else {
				bb = append(bb, b)
			}
		}
	}
	if bw == nil {
		_, err := w.Write(bb)
		return err
	}
	return nil

}

func readArrayDataPoint(r io.Reader) ([]*DataPoint, error) {
	var err error
	var blkSize int64
	var arr = make([]*DataPoint, 0)
	for {
		blkSize, err = readLong(r)
		if err != nil {
			return nil, err
		}
		if blkSize == 0 {
			break
		}
		if blkSize < 0 {
			blkSize = -blkSize
			_, err = readLong(r)
			if err != nil {
				return nil, err
			}
		}
		for i := int64(0); i < blkSize; i++ {
			elem, err := readDataPoint(r)
			if err != nil {
				return nil, err
			}
			arr = append(arr, elem)
		}
	}
	return arr, nil
}

func readArrayMetricData(r io.Reader) ([]*MetricData, error) {
	var err error
	var blkSize int64
	var arr = make([]*MetricData, 0)
	for {
		blkSize, err = readLong(r)
		if err != nil {
			return nil, err
		}
		if blkSize == 0 {
			break
		}
		if blkSize < 0 {
			blkSize = -blkSize
			_, err = readLong(r)
			if err != nil {
				return nil, err
			}
		}
		for i := int64(0); i < blkSize; i++ {
			elem, err := readMetricData(r)
			if err != nil {
				return nil, err
			}
			arr = append(arr, elem)
		}
	}
	return arr, nil
}

func readDataPackage(r io.Reader) (*DataPackage, error) {
	var str = &DataPackage{}
	var err error
	str.Generator, err = readInt(r)
	if err != nil {
		return nil, err
	}
	str.Organization, err = readInt(r)
	if err != nil {
		return nil, err
	}
	str.Region, err = readRegion(r)
	if err != nil {
		return nil, err
	}
	str.State, err = readState(r)
	if err != nil {
		return nil, err
	}
	str.Data, err = readArrayMetricData(r)
	if err != nil {
		return nil, err
	}

	return str, nil
}

func readDataPoint(r io.Reader) (*DataPoint, error) {
	var str = &DataPoint{}
	var err error
	str.Timestamp, err = readLong(r)
	if err != nil {
		return nil, err
	}
	str.Value, err = readUnionLongDouble(r)
	if err != nil {
		return nil, err
	}

	return str, nil
}

func readDouble(r io.Reader) (float64, error) {
	buf := make([]byte, 8)
	_, err := io.ReadFull(r, buf)
	if err != nil {
		return 0, err
	}
	bits := binary.LittleEndian.Uint64(buf)
	val := math.Float64frombits(bits)
	return val, nil
}

func readInt(r io.Reader) (int32, error) {
	var v int
	buf := make([]byte, 1)
	for shift := uint(0); ; shift += 7 {
		if _, err := io.ReadFull(r, buf); err != nil {
			return 0, err
		}
		b := buf[0]
		v |= int(b&127) << shift
		if b&128 == 0 {
			break
		}
	}
	datum := (int32(v>>1) ^ -int32(v&1))
	return datum, nil
}

func readLong(r io.Reader) (int64, error) {
	var v uint64
	buf := make([]byte, 1)
	for shift := uint(0); ; shift += 7 {
		if _, err := io.ReadFull(r, buf); err != nil {
			return 0, err
		}
		b := buf[0]
		v |= uint64(b&127) << shift
		if b&128 == 0 {
			break
		}
	}
	datum := (int64(v>>1) ^ -int64(v&1))
	return datum, nil
}

func readMetricData(r io.Reader) (*MetricData, error) {
	var str = &MetricData{}
	var err error
	str.Metric, err = readString(r)
	if err != nil {
		return nil, err
	}
	str.Datapoints, err = readArrayDataPoint(r)
	if err != nil {
		return nil, err
	}

	return str, nil
}

func readRegion(r io.Reader) (Region, error) {
	val, err := readInt(r)
	return Region(val), err
}

func readState(r io.Reader) (State, error) {
	val, err := readInt(r)
	return State(val), err
}

func readString(r io.Reader) (string, error) {
	len, err := readLong(r)
	if err != nil {
		return "", err
	}

	// makeslice can fail depending on available memory.
	// We arbitrarily limit string size to sane default (~2.2GB).
	if len < 0 || len > math.MaxInt32 {
		return "", fmt.Errorf("string length out of range: %d", len)
	}

	if len == 0 {
		return "", nil
	}

	bb := make([]byte, len)
	_, err = io.ReadFull(r, bb)
	if err != nil {
		return "", err
	}
	return string(bb), nil
}

func readUnionLongDouble(r io.Reader) (UnionLongDouble, error) {
	field, err := readLong(r)
	var unionStr UnionLongDouble
	if err != nil {
		return unionStr, err
	}
	unionStr.UnionType = UnionLongDoubleTypeEnum(field)
	switch unionStr.UnionType {
	case UnionLongDoubleTypeEnumLong:
		val, err := readLong(r)
		if err != nil {
			return unionStr, err
		}
		unionStr.Long = val
	case UnionLongDoubleTypeEnumDouble:
		val, err := readDouble(r)
		if err != nil {
			return unionStr, err
		}
		unionStr.Double = val

	default:
		return unionStr, fmt.Errorf("invalid value for UnionLongDouble")
	}
	return unionStr, nil
}

func writeArrayDataPoint(r []*DataPoint, w io.Writer) error {
	err := writeLong(int64(len(r)), w)
	if err != nil || len(r) == 0 {
		return err
	}
	for _, e := range r {
		err = writeDataPoint(e, w)
		if err != nil {
			return err
		}
	}
	return writeLong(0, w)
}

func writeArrayMetricData(r []*MetricData, w io.Writer) error {
	err := writeLong(int64(len(r)), w)
	if err != nil || len(r) == 0 {
		return err
	}
	for _, e := range r {
		err = writeMetricData(e, w)
		if err != nil {
			return err
		}
	}
	return writeLong(0, w)
}

func writeDataPackage(r *DataPackage, w io.Writer) error {
	var err error
	err = writeInt(r.Generator, w)
	if err != nil {
		return err
	}
	err = writeInt(r.Organization, w)
	if err != nil {
		return err
	}
	err = writeRegion(r.Region, w)
	if err != nil {
		return err
	}
	err = writeState(r.State, w)
	if err != nil {
		return err
	}
	err = writeArrayMetricData(r.Data, w)
	if err != nil {
		return err
	}

	return nil
}
func writeDataPoint(r *DataPoint, w io.Writer) error {
	var err error
	err = writeLong(r.Timestamp, w)
	if err != nil {
		return err
	}
	err = writeUnionLongDouble(r.Value, w)
	if err != nil {
		return err
	}

	return nil
}

func writeDouble(r float64, w io.Writer) error {
	bits := uint64(math.Float64bits(r))
	const byteCount = 8
	return encodeFloat(w, byteCount, bits)
}

func writeInt(r int32, w io.Writer) error {
	downShift := uint32(31)
	encoded := uint64((uint32(r) << 1) ^ uint32(r>>downShift))
	const maxByteSize = 5
	return encodeInt(w, maxByteSize, encoded)
}

func writeLong(r int64, w io.Writer) error {
	downShift := uint64(63)
	encoded := uint64((r << 1) ^ (r >> downShift))
	const maxByteSize = 10
	return encodeInt(w, maxByteSize, encoded)
}

func writeMetricData(r *MetricData, w io.Writer) error {
	var err error
	err = writeString(r.Metric, w)
	if err != nil {
		return err
	}
	err = writeArrayDataPoint(r.Datapoints, w)
	if err != nil {
		return err
	}

	return nil
}

func writeRegion(r Region, w io.Writer) error {
	return writeInt(int32(r), w)
}

func writeState(r State, w io.Writer) error {
	return writeInt(int32(r), w)
}

func writeString(r string, w io.Writer) error {
	err := writeLong(int64(len(r)), w)
	if err != nil {
		return err
	}
	if sw, ok := w.(StringWriter); ok {
		_, err = sw.WriteString(r)
	} else {
		_, err = w.Write([]byte(r))
	}
	return err
}

func writeUnionLongDouble(r UnionLongDouble, w io.Writer) error {
	err := writeLong(int64(r.UnionType), w)
	if err != nil {
		return err
	}
	switch r.UnionType {
	case UnionLongDoubleTypeEnumLong:
		return writeLong(r.Long, w)
	case UnionLongDoubleTypeEnumDouble:
		return writeDouble(r.Double, w)

	}
	return fmt.Errorf("invalid value for UnionLongDouble")
}