This commit is contained in:
Jae Kwon
2014-07-01 14:50:24 -07:00
parent fa07748d23
commit c40fc65e6b
41 changed files with 3176 additions and 2938 deletions

View File

@ -1,8 +1,8 @@
package binary
import (
"io"
"encoding/binary"
"encoding/binary"
"io"
)
type Byte byte
@ -17,397 +17,426 @@ type UInt64 uint64
type Int int
type UInt uint
// Byte
func (self Byte) Equals(other Binary) bool {
return self == other
return self == other
}
func (self Byte) Less(other Binary) bool {
if o, ok := other.(Byte); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(Byte); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self Byte) ByteSize() int {
return 1
return 1
}
func (self Byte) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write([]byte{byte(self)})
return int64(n), err
n, err := w.Write([]byte{byte(self)})
return int64(n), err
}
func ReadByteSafe(r io.Reader) (Byte, error) {
buf := [1]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return 0, err }
return Byte(buf[0]), nil
buf := [1]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return 0, err
}
return Byte(buf[0]), nil
}
func ReadByte(r io.Reader) (Byte) {
b, err := ReadByteSafe(r)
if err != nil { panic(err) }
return b
func ReadByte(r io.Reader) Byte {
b, err := ReadByteSafe(r)
if err != nil {
panic(err)
}
return b
}
// Int8
func (self Int8) Equals(other Binary) bool {
return self == other
return self == other
}
func (self Int8) Less(other Binary) bool {
if o, ok := other.(Int8); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(Int8); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self Int8) ByteSize() int {
return 1
return 1
}
func (self Int8) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write([]byte{byte(self)})
return int64(n), err
n, err := w.Write([]byte{byte(self)})
return int64(n), err
}
func ReadInt8Safe(r io.Reader) (Int8, error) {
buf := [1]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return Int8(0), err }
return Int8(buf[0]), nil
buf := [1]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return Int8(0), err
}
return Int8(buf[0]), nil
}
func ReadInt8(r io.Reader) (Int8) {
b, err := ReadInt8Safe(r)
if err != nil { panic(err) }
return b
func ReadInt8(r io.Reader) Int8 {
b, err := ReadInt8Safe(r)
if err != nil {
panic(err)
}
return b
}
// UInt8
func (self UInt8) Equals(other Binary) bool {
return self == other
return self == other
}
func (self UInt8) Less(other Binary) bool {
if o, ok := other.(UInt8); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(UInt8); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self UInt8) ByteSize() int {
return 1
return 1
}
func (self UInt8) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write([]byte{byte(self)})
return int64(n), err
n, err := w.Write([]byte{byte(self)})
return int64(n), err
}
func ReadUInt8Safe(r io.Reader) (UInt8, error) {
buf := [1]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return UInt8(0), err }
return UInt8(buf[0]), nil
buf := [1]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return UInt8(0), err
}
return UInt8(buf[0]), nil
}
func ReadUInt8(r io.Reader) (UInt8) {
b, err := ReadUInt8Safe(r)
if err != nil { panic(err) }
return b
func ReadUInt8(r io.Reader) UInt8 {
b, err := ReadUInt8Safe(r)
if err != nil {
panic(err)
}
return b
}
// Int16
func (self Int16) Equals(other Binary) bool {
return self == other
return self == other
}
func (self Int16) Less(other Binary) bool {
if o, ok := other.(Int16); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(Int16); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self Int16) ByteSize() int {
return 2
return 2
}
func (self Int16) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, int16(self))
return 2, err
err := binary.Write(w, binary.LittleEndian, int16(self))
return 2, err
}
func ReadInt16Safe(r io.Reader) (Int16, error) {
buf := [2]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return Int16(0), err }
return Int16(binary.LittleEndian.Uint16(buf[:])), nil
buf := [2]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return Int16(0), err
}
return Int16(binary.LittleEndian.Uint16(buf[:])), nil
}
func ReadInt16(r io.Reader) (Int16) {
b, err := ReadInt16Safe(r)
if err != nil { panic(err) }
return b
func ReadInt16(r io.Reader) Int16 {
b, err := ReadInt16Safe(r)
if err != nil {
panic(err)
}
return b
}
// UInt16
func (self UInt16) Equals(other Binary) bool {
return self == other
return self == other
}
func (self UInt16) Less(other Binary) bool {
if o, ok := other.(UInt16); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(UInt16); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self UInt16) ByteSize() int {
return 2
return 2
}
func (self UInt16) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, uint16(self))
return 2, err
err := binary.Write(w, binary.LittleEndian, uint16(self))
return 2, err
}
func ReadUInt16Safe(r io.Reader) (UInt16, error) {
buf := [2]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return UInt16(0), err }
return UInt16(binary.LittleEndian.Uint16(buf[:])), nil
buf := [2]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return UInt16(0), err
}
return UInt16(binary.LittleEndian.Uint16(buf[:])), nil
}
func ReadUInt16(r io.Reader) (UInt16) {
b, err := ReadUInt16Safe(r)
if err != nil { panic(err) }
return b
func ReadUInt16(r io.Reader) UInt16 {
b, err := ReadUInt16Safe(r)
if err != nil {
panic(err)
}
return b
}
// Int32
func (self Int32) Equals(other Binary) bool {
return self == other
return self == other
}
func (self Int32) Less(other Binary) bool {
if o, ok := other.(Int32); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(Int32); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self Int32) ByteSize() int {
return 4
return 4
}
func (self Int32) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, int32(self))
return 4, err
err := binary.Write(w, binary.LittleEndian, int32(self))
return 4, err
}
func ReadInt32Safe(r io.Reader) (Int32, error) {
buf := [4]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return Int32(0), err }
return Int32(binary.LittleEndian.Uint32(buf[:])), nil
buf := [4]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return Int32(0), err
}
return Int32(binary.LittleEndian.Uint32(buf[:])), nil
}
func ReadInt32(r io.Reader) (Int32) {
b, err := ReadInt32Safe(r)
if err != nil { panic(err) }
return b
func ReadInt32(r io.Reader) Int32 {
b, err := ReadInt32Safe(r)
if err != nil {
panic(err)
}
return b
}
// UInt32
func (self UInt32) Equals(other Binary) bool {
return self == other
return self == other
}
func (self UInt32) Less(other Binary) bool {
if o, ok := other.(UInt32); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(UInt32); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self UInt32) ByteSize() int {
return 4
return 4
}
func (self UInt32) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, uint32(self))
return 4, err
err := binary.Write(w, binary.LittleEndian, uint32(self))
return 4, err
}
func ReadUInt32Safe(r io.Reader) (UInt32, error) {
buf := [4]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return UInt32(0), err }
return UInt32(binary.LittleEndian.Uint32(buf[:])), nil
buf := [4]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return UInt32(0), err
}
return UInt32(binary.LittleEndian.Uint32(buf[:])), nil
}
func ReadUInt32(r io.Reader) (UInt32) {
b, err := ReadUInt32Safe(r)
if err != nil { panic(err) }
return b
func ReadUInt32(r io.Reader) UInt32 {
b, err := ReadUInt32Safe(r)
if err != nil {
panic(err)
}
return b
}
// Int64
func (self Int64) Equals(other Binary) bool {
return self == other
return self == other
}
func (self Int64) Less(other Binary) bool {
if o, ok := other.(Int64); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(Int64); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self Int64) ByteSize() int {
return 8
return 8
}
func (self Int64) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, int64(self))
return 8, err
err := binary.Write(w, binary.LittleEndian, int64(self))
return 8, err
}
func ReadInt64Safe(r io.Reader) (Int64, error) {
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return Int64(0), err }
return Int64(binary.LittleEndian.Uint64(buf[:])), nil
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return Int64(0), err
}
return Int64(binary.LittleEndian.Uint64(buf[:])), nil
}
func ReadInt64(r io.Reader) (Int64) {
b, err := ReadInt64Safe(r)
if err != nil { panic(err) }
return b
func ReadInt64(r io.Reader) Int64 {
b, err := ReadInt64Safe(r)
if err != nil {
panic(err)
}
return b
}
// UInt64
func (self UInt64) Equals(other Binary) bool {
return self == other
return self == other
}
func (self UInt64) Less(other Binary) bool {
if o, ok := other.(UInt64); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(UInt64); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self UInt64) ByteSize() int {
return 8
return 8
}
func (self UInt64) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, uint64(self))
return 8, err
err := binary.Write(w, binary.LittleEndian, uint64(self))
return 8, err
}
func ReadUInt64Safe(r io.Reader) (UInt64, error) {
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { return UInt64(0), err }
return UInt64(binary.LittleEndian.Uint64(buf[:])), nil
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
return UInt64(0), err
}
return UInt64(binary.LittleEndian.Uint64(buf[:])), nil
}
func ReadUInt64(r io.Reader) (UInt64) {
b, err := ReadUInt64Safe(r)
if err != nil { panic(err) }
return b
func ReadUInt64(r io.Reader) UInt64 {
b, err := ReadUInt64Safe(r)
if err != nil {
panic(err)
}
return b
}
// Int
func (self Int) Equals(other Binary) bool {
return self == other
return self == other
}
func (self Int) Less(other Binary) bool {
if o, ok := other.(Int); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(Int); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self Int) ByteSize() int {
return 8
return 8
}
func (self Int) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, int64(self))
return 8, err
err := binary.Write(w, binary.LittleEndian, int64(self))
return 8, err
}
func ReadInt(r io.Reader) Int {
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { panic(err) }
return Int(binary.LittleEndian.Uint64(buf[:]))
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
panic(err)
}
return Int(binary.LittleEndian.Uint64(buf[:]))
}
// UInt
func (self UInt) Equals(other Binary) bool {
return self == other
return self == other
}
func (self UInt) Less(other Binary) bool {
if o, ok := other.(UInt); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
if o, ok := other.(UInt); ok {
return self < o
} else {
panic("Cannot compare unequal types")
}
}
func (self UInt) ByteSize() int {
return 8
return 8
}
func (self UInt) WriteTo(w io.Writer) (int64, error) {
err := binary.Write(w, binary.LittleEndian, uint64(self))
return 8, err
err := binary.Write(w, binary.LittleEndian, uint64(self))
return 8, err
}
func ReadUInt(r io.Reader) UInt {
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil { panic(err) }
return UInt(binary.LittleEndian.Uint64(buf[:]))
buf := [8]byte{0}
_, err := io.ReadFull(r, buf[:])
if err != nil {
panic(err)
}
return UInt(binary.LittleEndian.Uint64(buf[:]))
}