code review 5146048: encoding/binary: support for varint encoding

src/pkg/encoding/binary/varint.go

+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package binary
+
+import (
+        "io"
+        "os"
+)
+
+// PutUint encodes a uint64 into buf and returns the number of bytes written.
+// If the buffer is to small, the result is 0.
+func PutUint(buf []byte, x uint64) int {
+        for i := range buf {
+                if x < 128 {
+                        buf[i] = byte(x)
+                        return i + 1
+                }
+                buf[i] = byte(x) | 128
+                x >>= 7
+        }
+        return 0 // error: buffer too small
+}
+
+// Uint decodes a uint64 from buf and returns that value and the
+// number of bytes read. If the buffer is too small, the value is
+// undefined and the number of bytes is 0. At most 11 bytes are read.
+func Uint(buf []byte) (uint64, int) {
+        var x uint64
+        var s uint
+        for i, b := range buf {
+                if b < 128 || i >= 10 {
+                        return x | uint64(b)<<s, i + 1
+                }
+                x |= uint64(b&127) << s
+                s += 7
+        }
+        return x, 0
+}
+
+// PutInt encodes an int64 into buf and returns the number of bytes written.
+// If the buffer is to small, the result is 0.
+func PutInt(buf []byte, x int64) int {
+        ux := uint64(x) << 1
+        if x < 0 {
+                ux = ^ux
+        }
+        return PutUint(buf, ux)
+}
+
+// Int decodes an int64 from buf and returns that value and the
+// number of bytes read. If the buffer is too small, the value is
+// undefined and the number of bytes is 0. At most 11 bytes are read.
+func Int(buf []byte) (int64, int) {
+        ux, n := Uint(buf) // ok to continue in presence of error
+        x := int64(ux >> 1)
+        if ux&1 != 0 {
+                x = ^x
+        }
+        return x, n
+}
+
+// WriteUint writes a uint64 to w.
+func WriteUint(w io.Writer, x uint64) os.Error {
+        var buf [10]byte
+        n := PutUint(buf[:], x) // won't fail
+        _, err := w.Write(buf[0:n])
+        return err
+}
+
+var overflow = os.NewError("overflow: not a 64bit integer")
+
+// ReadUint reads a uint64 from r.
+func ReadUint(r io.ByteReader) (uint64, os.Error) {
+        var x uint64
+        var s uint
+        for i := 0; i < 10; i++ {
+                b, err := r.ReadByte()
+                if b < 128 || err != nil {
+                        return x | uint64(b)<<s, err
+                }
+                x |= uint64(b&127) << s
+                s += 7
+        }
+        return x, overflow
+}
+
+// WriteInt writes a uint64 to w.
+func WriteInt(w io.Writer, x int64) os.Error {
+        ux := uint64(x) << 1
+        if x < 0 {
+                ux = ^ux
+        }
+        return WriteUint(w, ux)
+}
+
+// ReadInt reads a uint64 from r.
+func ReadInt(r io.ByteReader) (int64, os.Error) {
+        ux, err := ReadUint(r) // ok to continue in presence of error
+        x := int64(ux >> 1)
+        if ux&1 != 0 {
+                x = ^x
+        }
+        return x, err
+}