gnet: 优化 binary 实现

gnet/binary.go

@@ -68,69 +68,67 @@ func binarySplit(p []byte, bitMasks []byte) (*BitSplit, error) {
 
 type bigEndian struct{}
 
-func (b *bigEndian) PutUint16(u uint16) []byte {
-	p := make([]byte, 2)
-	binary.BigEndian.PutUint16(p, u)
-	return p
+func (bigEndian) String() string { return "BigEndian" }
+
+func (bigEndian) GoString() string { return "gnet.BigEndian" }
+
+func (bigEndian) PutUint16(b []byte, v uint16) {
+	binary.BigEndian.PutUint16(b, v)
 }
 
-func (b *bigEndian) PutUint32(u uint32) []byte {
-	p := make([]byte, 4)
-	binary.BigEndian.PutUint32(p, u)
-	return p
+func (bigEndian) PutUint32(b []byte, v uint32) {
+	binary.BigEndian.PutUint32(b, v)
 }
 
-func (b *bigEndian) PutUint64(u uint64) []byte {
-	p := make([]byte, 8)
-	binary.BigEndian.PutUint64(p, u)
-	return p
+func (bigEndian) PutUint64(b []byte, v uint64) {
+	binary.BigEndian.PutUint64(b, v)
 }
 
-func (b *bigEndian) BitSplit(p []byte) (*BitSplit, error) {
+func (b bigEndian) BitSplit(p []byte) (*BitSplit, error) {
 	return binarySplit(p, bitMasksBig)
 }
 
-func (b *bigEndian) Int16(p []byte) int16 {
+func (b bigEndian) Int16(p []byte) int16 {
 	return int16(NegativeCovert(int64(b.Uint16(p))))
 }
 
-func (b *bigEndian) Int32(p []byte) int32 {
+func (b bigEndian) Int32(p []byte) int32 {
 	return int32(NegativeCovert(int64(b.Uint32(p))))
 }
 
-func (b *bigEndian) Int64(p []byte) int64 {
+func (b bigEndian) Int64(p []byte) int64 {
 	return NegativeCovert(int64(b.Uint32(p)))
 }
 
-func (b *bigEndian) Uint16(p []byte) uint16 {
+func (b bigEndian) Uint16(p []byte) uint16 {
 	if len(p) != 2 {
 		return 0
 	}
 	return binary.BigEndian.Uint16(p)
 }
 
-func (b *bigEndian) Uint32(p []byte) uint32 {
+func (b bigEndian) Uint32(p []byte) uint32 {
 	if len(p) != 4 {
 		return 0
 	}
 	return binary.BigEndian.Uint32(p)
 }
 
-func (b *bigEndian) Uint64(p []byte) uint64 {
+func (b bigEndian) Uint64(p []byte) uint64 {
 	if len(p) != 8 {
 		return 0
 	}
 	return binary.BigEndian.Uint64(p)
 }
 
-func (b *bigEndian) Float32(p []byte) float32 {
+func (b bigEndian) Float32(p []byte) float32 {
 	if len(p) != 4 {
 		return 0
 	}
 	return math.Float32frombits(b.Uint32(p))
 }
 
-func (b *bigEndian) Float64(p []byte) float64 {
+func (b bigEndian) Float64(p []byte) float64 {
 	if len(p) != 8 {
 		return 0
 	}
@@ -139,70 +137,68 @@ func (b *bigEndian) Float64(p []byte) float64 {
 
 type littleEndian struct{}
 
-func (l *littleEndian) PutUint16(u uint16) []byte {
-	p := make([]byte, 2)
-	binary.LittleEndian.PutUint16(p, u)
-	return p
+func (littleEndian) String() string { return "LittleEndian" }
+
+func (littleEndian) GoString() string { return "gnet.LittleEndian" }
+
+func (littleEndian) PutUint16(b []byte, v uint16) {
+	binary.LittleEndian.PutUint16(b, v)
 }
 
-func (l *littleEndian) PutUint32(u uint32) []byte {
-	p := make([]byte, 4)
-	binary.LittleEndian.PutUint32(p, u)
-	return p
+func (littleEndian) PutUint32(b []byte, v uint32) {
+	binary.LittleEndian.PutUint32(b, v)
 }
 
-func (l *littleEndian) PutUint64(u uint64) []byte {
-	p := make([]byte, 8)
-	binary.LittleEndian.PutUint64(p, u)
-	return p
+func (littleEndian) PutUint64(b []byte, v uint64) {
+	binary.LittleEndian.PutUint64(b, v)
 }
 
-func (l *littleEndian) BitSplit(p []byte) (*BitSplit, error) {
+func (littleEndian) BitSplit(p []byte) (*BitSplit, error) {
 	return binarySplit(p, bitMasksLittle)
 }
 
 // Int16 Range: -32768 through 32767.
-func (l *littleEndian) Int16(p []byte) int16 {
+func (l littleEndian) Int16(p []byte) int16 {
 	return int16(NegativeCovert(int64(l.Uint16(p))))
 }
 
-func (l *littleEndian) Int32(p []byte) int32 {
+func (l littleEndian) Int32(p []byte) int32 {
 	return int32(NegativeCovert(int64(l.Uint32(p))))
 }
 
-func (l *littleEndian) Int64(p []byte) int64 {
+func (l littleEndian) Int64(p []byte) int64 {
 	return NegativeCovert(int64(l.Uint32(p)))
 }
 
-func (l *littleEndian) Uint16(p []byte) uint16 {
+func (littleEndian) Uint16(p []byte) uint16 {
 	if len(p) != 2 {
 		return 0
 	}
 	return binary.LittleEndian.Uint16(p)
 }
 
-func (l *littleEndian) Uint32(p []byte) uint32 {
+func (littleEndian) Uint32(p []byte) uint32 {
 	if len(p) != 4 {
 		return 0
 	}
 	return binary.LittleEndian.Uint32(p)
 }
 
-func (l *littleEndian) Uint64(b []byte) uint64 {
+func (littleEndian) Uint64(b []byte) uint64 {
 	if len(b) != 8 {
 		return 0
 	}
 	return binary.LittleEndian.Uint64(b)
 }
 
-func (l *littleEndian) Float32(p []byte) float32 {
+func (l littleEndian) Float32(p []byte) float32 {
 	if len(p) != 4 {
 		return 0
 	}
 	return math.Float32frombits(l.Uint32(p))
 }
 
-func (l *littleEndian) Float64(p []byte) float64 {
+func (l littleEndian) Float64(p []byte) float64 {
 	if len(p) != 8 {
 		return 0
 	}
@@ -223,14 +219,14 @@ func NegativeCovert(i int64) int64 {
 // LittleEndian 低位字节在前, 高位字节在后. 即 0x1122
 // 只有读取的时候才必须区分字节序, 其他情况都不用考虑
 var (
-	BigEndian    = &bigEndian{}
-	LittleEndian = &littleEndian{}
+	BigEndian    bigEndian
+	LittleEndian littleEndian
 )
 
 type BinaryOrder interface {
-	PutUint16(u uint16) []byte
-	PutUint32(u uint32) []byte
-	PutUint64(u uint64) []byte
+	PutUint16(b []byte, v uint16)
+	PutUint32(b []byte, v uint32)
+	PutUint64(b []byte, v uint64)
 	Int16(p []byte) int16
 	Int32(p []byte) int32
 	Int64(p []byte) int64