improve complex pack performance

field.go

@@ -70,7 +70,7 @@ func (f *Field) Size(val reflect.Value) int {
 	}
 }
 
-func (f *Field) packVal(buf []byte, val reflect.Value, length int) error {
+func (f *Field) packVal(buf []byte, val reflect.Value, length int) (size int, err error) {
 	order := f.Order
 	if f.Ptr {
 		val = val.Elem()
@@ -79,6 +79,7 @@ func (f *Field) packVal(buf []byte, val reflect.Value, length int) error {
 	case Struct:
 		return f.Fields.Pack(buf, val)
 	case Bool, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64:
+		size = f.Type.Size()
 		var n uint64
 		switch f.kind {
 		case reflect.Bool:
@@ -109,6 +110,7 @@ func (f *Field) packVal(buf []byte, val reflect.Value, length int) error {
 			order.PutUint64(buf, uint64(n))
 		}
 	case Float32, Float64:
+		size = f.Type.Size()
 		n := val.Float()
 		switch f.Type {
 		case Float32:
@@ -119,42 +121,40 @@ func (f *Field) packVal(buf []byte, val reflect.Value, length int) error {
 	case String:
 		switch f.kind {
 		case reflect.String:
+			size = val.Len()
 			copy(buf, []byte(val.String()))
 		default:
 			// TODO: handle kind != bytes here
+			size = val.Len()
 			copy(buf, val.Bytes())
 		}
 	}
-	return nil
+	return
 }
 
-func (f *Field) Pack(buf []byte, val reflect.Value, length int) error {
+func (f *Field) Pack(buf []byte, val reflect.Value, length int) (int, error) {
 	if f.Type == Pad {
 		for i := 0; i < length; i++ {
 			buf[i] = 0
 		}
-		return nil
+		return length, nil
 	}
 	if f.Slice {
 		// special case byte slices for performance
 		if !f.Array && f.Type == Uint8 && f.defType == Uint8 {
 			copy(buf, val.Bytes())
-			return nil
+			return val.Len(), nil
 		}
 		pos := 0
 		for i := 0; i < length; i++ {
 			cur := val.Index(i)
-			if err := f.packVal(buf[pos:], cur, 1); err != nil {
-				return err
-			}
-			// TODO: make packVal() return the length?
-			if f.Type == Struct {
-				pos += f.Fields.Sizeof(cur)
+			if n, err := f.packVal(buf[pos:], cur, 1); err != nil {
+				return pos, err
 			} else {
-				pos += f.Type.Size()
+				pos += n
 			}
 		}
-		return nil
+		return pos, nil
 	} else {
 		return f.packVal(buf, val, length)
 	}

fields.go

@@ -37,7 +37,7 @@ func (f Fields) Sizeof(val reflect.Value) int {
 	return size
 }
 
-func (f Fields) Pack(buf []byte, val reflect.Value) error {
+func (f Fields) Pack(buf []byte, val reflect.Value) (int, error) {
 	for val.Kind() == reflect.Ptr {
 		val = val.Elem()
 	}
@@ -58,13 +58,13 @@ func (f Fields) Pack(buf []byte, val reflect.Value) error {
 			length := val.FieldByIndex(field.Sizeof).Len()
 			v = reflect.ValueOf(length)
 		}
-		err := field.Pack(buf[pos:], v, length)
-		if err != nil {
-			return err
+		if n, err := field.Pack(buf[pos:], v, length); err != nil {
+			return n, err
+		} else {
+			pos += n
 		}
-		pos += field.Size(v)
 	}
-	return nil
+	return pos, nil
 }
 
 func (f Fields) Unpack(r io.Reader, val reflect.Value) error {

packable.go

@@ -27,7 +27,7 @@ type Packable interface {
 	SetByteOrder(order binary.ByteOrder)
 	String() string
 	Sizeof(val reflect.Value) int
-	Pack(buf []byte, val reflect.Value) error
+	Pack(buf []byte, val reflect.Value) (int, error)
 	Unpack(r io.Reader, val reflect.Value) error
 }
 
@@ -48,9 +48,10 @@ func (b *binaryFallback) Sizeof(val reflect.Value) int {
 	return binary.Size(val.Interface())
 }
 
-func (b *binaryFallback) Pack(buf []byte, val reflect.Value) error {
+func (b *binaryFallback) Pack(buf []byte, val reflect.Value) (int, error) {
 	tmp := byteWriter{buf: buf}
-	return binary.Write(tmp, b.order, val.Interface())
+	err := binary.Write(tmp, b.order, val.Interface())
+	return tmp.pos, err
 }
 
 func (b *binaryFallback) Unpack(r io.Reader, val reflect.Value) error {

struc.go

@@ -47,7 +47,7 @@ func PackWithOrder(w io.Writer, data interface{}, order binary.ByteOrder) error
 	}
 	size := fields.Sizeof(val)
 	buf := make([]byte, size)
-	if err := fields.Pack(buf, val); err != nil {
+	if _, err := fields.Pack(buf, val); err != nil {
 		return err
 	}
 	_, err = w.Write(buf)