Throw the code out there. :)

pkg/packetdatastream/packetdatastream.go

@@ -0,0 +1,326 @@
+// Grumble - an implementation of Murmur in Go
+// Copyright (c) 2010 The Grumble Authors
+// The use of this source code is goverened by a BSD-style
+// license that can be found in the LICENSE-file.
+
+package packetdatastream
+
+import (
+	"math"
+)
+
+type PacketDataStream struct {
+	Buf []byte
+	offset int
+	maxsize int
+	overshoot int
+	ok bool
+}
+
+func New(buf []byte) (pds *PacketDataStream) {
+	pds = new(PacketDataStream)
+	pds.Buf = buf
+	pds.maxsize = len(buf)
+	pds.ok = true
+	return
+}
+
+func (pds *PacketDataStream) IsValid() bool {
+	return pds.ok
+}
+
+func (pds *PacketDataStream) Skip(skip int) {
+	if pds.Left() >= skip {
+		pds.offset += skip
+	} else {
+		pds.ok = false
+	}
+}
+
+// Returns number of bytes remaining in
+// the buffer.
+func (pds *PacketDataStream) Left() int {
+	return int(pds.maxsize - pds.offset)
+}
+
+// Returns the size of the currently-assembled data
+// stream
+func (pds *PacketDataStream) Size() int {
+	return pds.offset
+}
+
+// Get the next byte from the PacketDataStream as a uint64
+func (pds *PacketDataStream) next() (ret uint64) {
+	if pds.offset < pds.maxsize {
+		ret = uint64(pds.Buf[pds.offset])
+		pds.offset += 1
+		return
+	} else {
+		pds.ok = false
+	}
+	return 0
+}
+
+// Get the next byte from the PacketDataStream as a byte (uint8)
+func (pds *PacketDataStream) Next8() (ret uint8) {
+	if pds.offset < pds.maxsize {
+		ret = uint8(pds.Buf[pds.offset])
+		pds.offset += 1
+		return
+	} else {
+		pds.ok = false
+	}
+	return 0
+}
+
+// Put a byte (represented in an uint64) into the
+// PacketDataStream.
+func (pds *PacketDataStream) append(val uint64) {
+	if (val > 0xff) {
+		pds.ok = false
+		return
+	}
+
+	if pds.offset < pds.maxsize {
+		pds.Buf[pds.offset] = byte(val)
+		pds.offset += 1
+	} else {
+		pds.ok = false
+		pds.overshoot++
+	}
+
+}
+
+// Add a variably-sized integer to the PacketDataStream.
+// The PacketDataStream will figure out the most efficient
+// encoding based on the binary representation of the value.
+func (pds *PacketDataStream) addVarint(val uint64) {
+	i := val
+
+	if (i & 0x8000000000000000) != 0 && ^i < 0x100000000 {
+		// Signed number
+		i = ^i
+		if i <= 0x3 {
+			// Short for -1 to -4
+			pds.append(0xfc | i)
+		} else {
+			pds.append(0xf8)
+		}
+	}
+	if i < 0x80 {
+		// Needs top bit clear
+		pds.append(i)
+	} else if i < 0x4000 {
+		// Needs two top bits clear
+		pds.append((i >> 8) | 0x80)
+		pds.append(i & 0xff)
+	} else if i < 0x10000000 {
+		// Needs three top bits clear
+		pds.append((i >> 16) | 0xc0)
+		pds.append((i >> 8) & 0xff)
+		pds.append(i & 0xff)
+	} else if i < 0x100000000 {
+		// Full 32 bit integer
+		pds.append(0xf0)
+		pds.append((i >> 24) & 0xff)
+		pds.append((i >> 16) & 0xff)
+		pds.append((i >> 8) & 0xff)
+		pds.append(i & 0xff)
+	} else {
+		// 64 bit val
+		pds.append(0xf4)
+		pds.append((i >> 56) & 0xff)
+		pds.append((i >> 48) & 0xff)
+		pds.append((i >> 40) & 0xff)
+		pds.append((i >> 32) & 0xff)
+		pds.append((i >> 24) & 0xff)
+		pds.append((i >> 16) & 0xff)
+		pds.append((i >> 8) & 0xff)
+		pds.append(i & 0xff)
+	}
+}
+
+func (pds *PacketDataStream) getVarint() (i uint64) {
+	v := pds.next()
+
+	if (v & 0x80) == 0x00 {
+		i = (v & 0x7f)
+	} else if (v & 0xc0) == 0x80 {
+		i = (v & 0x3f) << 8 | pds.next()
+	} else if (v & 0xf0) == 0xf0 {
+		switch v & 0xfc {
+		case 0xf0:
+			i = pds.next() << 24 | pds.next() << 16 | pds.next() << 8 | pds.next()
+		case 0xf4:
+			i = pds.next() << 56 | pds.next() << 48 | pds.next() << 40 | pds.next() << 32 | pds.next() << 24 | pds.next() << 16 | pds.next() << 8 | pds.next()
+		case 0xf8:
+			i = ^pds.getVarint()
+		case 0xfc:
+			i = ^(v & 0x03)
+		default:
+			pds.ok = false
+			i = 0
+		}
+	} else if (v & 0xf0) == 0xe0 {
+		i = (v & 0x0f) << 24 | pds.next() << 16 | pds.next() << 8 | pds.next()
+	} else if (v & 0xe0) == 0xc0 {
+		i = (v & 0x1f) << 16 | pds.next() << 8 | pds.next()
+	}
+
+	return
+}
+
+// Read a uint64 from the PacketDataStream
+func (pds *PacketDataStream) GetUint64() uint64 {
+	return pds.getVarint()
+}
+
+// Write a uint64 to the PacketDataStream
+func (pds *PacketDataStream) PutUint64(val uint64) {
+	pds.addVarint(val)
+}
+
+// Read a uint32 from the PacketDataStream
+func (pds *PacketDataStream) GetUint32() uint32 {
+	return uint32(pds.getVarint())
+}
+
+// Write a uint32 to the PacketDataStream
+func (pds *PacketDataStream) PutUint32(val uint32) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a uint16 from the PacketDataStream
+func (pds *PacketDataStream) GetUint16() uint16 {
+	return uint16(pds.getVarint())
+}
+
+// Write a uint16 to the PacketDataStream
+func (pds *PacketDataStream) PutUint16(val uint16) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a uint8 from the PacketDataStream
+func (pds *PacketDataStream) GetUint8() uint8 {
+	varint := pds.getVarint()
+	return uint8(varint)
+}
+
+// Write a uint8 to the PacketDataStream
+func (pds *PacketDataStream) PutUint8(val uint8) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a int64 from the PacketDataStream
+func (pds *PacketDataStream) GetInt64() int64 {
+	return int64(pds.getVarint())
+}
+
+// Write a int64 to the PacketDataStream
+func (pds *PacketDataStream) PutInt64(val int64) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a int32 from the PacketDataStream
+func (pds *PacketDataStream) GetInt32() int32 {
+	return int32(pds.getVarint())
+}
+
+// Write a int32 to the PacketDataStream
+func (pds *PacketDataStream) PutInt32(val int32) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a int16 from the PacketDataStream
+func (pds *PacketDataStream) GetInt16() int16 {
+	return int16(pds.getVarint())
+}
+
+// Write a int16 to the PacketDataStream
+func (pds *PacketDataStream) PutInt16(val int16) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a int8 from the PacketDataStream
+func (pds *PacketDataStream) GetInt8() int8 {
+	return int8(pds.getVarint())
+}
+
+// Write a int8 to the PacketDataStream
+func (pds *PacketDataStream) PutInt8(val int8) {
+	pds.addVarint(uint64(val))
+}
+
+// Read a float32 from the PacketDataStream
+func (pds *PacketDataStream) GetFloat32() float32 {
+	if pds.Left() < 4 {
+		pds.ok = false
+		return 0
+	}
+
+	var val uint32
+
+	val = uint32(pds.Next8()) << 24 | uint32(pds.Next8()) << 16 | uint32(pds.Next8()) << 8 | uint32(pds.Next8())
+	return math.Float32frombits(val)
+}
+
+// Write a float32 to the PacketDataStream
+func (pds *PacketDataStream) PutFloat32(val float32) {
+	bits := math.Float32bits(val)
+	pds.append(uint64((bits >> 24) & 0xff))
+	pds.append(uint64((bits >> 16) & 0xff))
+	pds.append(uint64((bits >> 8) & 0xff))
+	pds.append(uint64(bits & 0xff))
+}
+
+// Read a float64 from the PacketDataStream.
+func (pds *PacketDataStream) GetFloat64() float64 {
+	if pds.Left() < 8 {
+		pds.ok = false
+		return 0
+	}
+
+	var val uint64
+	val = uint64(pds.Next8()) << 56 | uint64(pds.Next8()) << 48 | uint64(pds.Next8()) << 40 | uint64(pds.Next8()) << 32 | uint64(pds.Next8()) << 24 | uint64(pds.Next8()) << 16 | uint64(pds.Next8()) << 8 | uint64(pds.Next8())
+
+	return math.Float64frombits(val)
+}
+
+// Write a float64 to the PacketDataStream
+func (pds *PacketDataStream) PutFloat64(val float64) {
+	bits := math.Float64bits(val)
+	pds.append((bits >> 56) & 0xff)
+	pds.append((bits >> 48) & 0xff)
+	pds.append((bits >> 40) & 0xff)
+	pds.append((bits >> 32) & 0xff)
+	pds.append((bits >> 24) & 0xff)
+	pds.append((bits >> 16) & 0xff)
+	pds.append((bits >> 8) & 0xff)
+	pds.append(bits & 0xff)
+}
+
+// Copy a buffer out of the PacketDataStream into dst.
+func (pds *PacketDataStream) CopyBytes(dst []byte) {
+	if pds.Left() >= len(dst) {
+		if copy(dst, pds.Buf[pds.offset:pds.offset+len(dst)]) != len(dst) {
+			pds.ok = false
+		}
+	} else {
+		pds.ok = false
+	}
+}
+
+// Put a buffer src into the PacketDataStream at the
+// current offset.
+func (pds *PacketDataStream) PutBytes(src []byte) {
+	if pds.Left() >= len(src) {
+		if copy(pds.Buf[pds.offset:pds.offset+len(src)], src) != len(src) {
+			pds.ok = false
+		} else {
+			pds.offset += len(src)
+		}
+	} else {
+		pds.overshoot += len(src) - pds.Left()
+		pds.ok = false
+	}
+}