fixed algorithm

binary/byteslice.go

@@ -4,8 +4,6 @@ import (
 	"io"
 )
 
-// ByteSlice
-
 func WriteByteSlice(w io.Writer, bz []byte, n *int64, err *error) {
 	WriteUInt32(w, uint32(len(bz)), n, err)
 	WriteTo(w, bz, n, err)
@@ -20,3 +18,31 @@ func ReadByteSlice(r io.Reader, n *int64, err *error) []byte {
 	ReadFull(r, buf, n, err)
 	return buf
 }
+
+//-----------------------------------------------------------------------------
+
+func WriteByteSlices(w io.Writer, bzz [][]byte, n *int64, err *error) {
+	WriteUInt32(w, uint32(len(bzz)), n, err)
+	for _, bz := range bzz {
+		WriteByteSlice(w, bz, n, err)
+		if *err != nil {
+			return
+		}
+	}
+}
+
+func ReadByteSlices(r io.Reader, n *int64, err *error) [][]byte {
+	length := ReadUInt32(r, n, err)
+	if *err != nil {
+		return nil
+	}
+	bzz := make([][]byte, length)
+	for i := uint32(0); i < length; i++ {
+		bz := ReadByteSlice(r, n, err)
+		if *err != nil {
+			return nil
+		}
+		bzz[i] = bz
+	}
+	return bzz
+}

binary/int.go

@@ -68,6 +68,34 @@ func ReadUInt16(r io.Reader, n *int64, err *error) uint16 {
 	return uint16(binary.LittleEndian.Uint16(buf))
 }
 
+// []UInt16
+
+func WriteUInt16s(w io.Writer, iz []uint16, n *int64, err *error) {
+	WriteUInt32(w, uint32(len(iz)), n, err)
+	for _, i := range iz {
+		WriteUInt16(w, i, n, err)
+		if *err != nil {
+			return
+		}
+	}
+}
+
+func ReadUInt16s(r io.Reader, n *int64, err *error) []uint16 {
+	length := ReadUInt32(r, n, err)
+	if *err != nil {
+		return nil
+	}
+	iz := make([]uint16, length)
+	for j := uint32(0); j < length; j++ {
+		ii := ReadUInt16(r, n, err)
+		if *err != nil {
+			return nil
+		}
+		iz[j] = ii
+	}
+	return iz
+}
+
 // Int32
 
 func WriteInt32(w io.Writer, i int32, n *int64, err *error) {