Split Buffer into WriteBuffer/ReadBuffer.

service/datastore/serialize/invertible.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package serialize
 
 import (
         "bytes"
 )
 
-// Buffer is the interface which corresponds to the subset of *bytes.Buffer
+// WriteBuffer is the interface which corresponds to the subset of *bytes.Buffer
 // that this package requires.
-type Buffer interface {
+type WriteBuffer interface {
+        ReadBuffer
+
         String() string
         Bytes() []byte
-        Len() int
 
         Grow(int)
 
-        Read([]byte) (int, error)
-        ReadByte() (byte, error)
-
         Write([]byte) (int, error)
         WriteByte(c byte) error
         WriteString(s string) (int, error)
 }
 
-var _ Buffer = (*bytes.Buffer)(nil)
+// ReadBuffer is the interface which corresponds to the subset of *bytes.Reader
+// that this package requires.
+type ReadBuffer interface {
+        Len() int
+
+        Read([]byte) (int, error)
+        ReadByte() (byte, error)
+}
+
+var (
+        _ WriteBuffer = (*bytes.Buffer)(nil)
+        _ ReadBuffer  = (*bytes.Reader)(nil)
+)
 
 // InvertibleBuffer is just like Buffer, except that it also has a stateful
 // Invert() method, which will cause all reads and writes to/from it to be
 // inverted (e.g. every byte XOR 0xFF).
 //
 // Implementing queries requires manipulating the index entries (e.g.
 // synthesizing them, parsing them, etc.). In particular, when you have
 // a reverse-sorted field (e.g. high to low instead of low to high), it's
 // achieved by having all the bits inverted.
 //
 // All the serialization formats include delimiter information, which the
 // parsers only know to parse non-inverted. If we don't have this buffer, we'd
 // basically have to invert every byte in the []byte array when we're trying to
 // decode a reverse-ordered field (including the bytes of all fields after the
 // one we intend to parse) so that the parser can consume as many bytes as it
 // needs (and it only knows the number of bytes it needs as it decodes them).
 // This InvertibleBuffer lets that happen on the fly without having to flip the
 // whole []byte.
 //
 // If you know you need it, you'll know it's the right thing. If you're not sure
 // then you definitely don't need it!
 type InvertibleBuffer interface {
-        Buffer
+        WriteBuffer
         SetInvert(inverted bool)
 }
 
 type invertibleBuffer struct {
-        Buffer
+        WriteBuffer
         invert bool
 }
 
 // Invertible returns an InvertibleBuffer based on the Buffer.
-func Invertible(b Buffer) InvertibleBuffer {
+func Invertible(b WriteBuffer) InvertibleBuffer {
         return &invertibleBuffer{b, false}
 }
 
 func (ib *invertibleBuffer) Read(bs []byte) (int, error) {
-        n, err := ib.Buffer.Read(bs)
+        n, err := ib.WriteBuffer.Read(bs)
         if ib.invert {
                 for i, b := range bs {
                         bs[i] = b ^ 0xFF
                 }
         }
         return n, err
 }
 
 func (ib *invertibleBuffer) WriteString(s string) (int, error) {
         if ib.invert {
                 ib.Grow(len(s))
                 for i := 0; i < len(s); i++ {
-                        if err := ib.Buffer.WriteByte(s[i] ^ 0xFF); err != nil {
+                        if err := ib.WriteBuffer.WriteByte(s[i] ^ 0xFF); err != nil {
                                 return i, err
                         }
                 }
                 return len(s), nil
         }
-        return ib.Buffer.WriteString(s)
+        return ib.WriteBuffer.WriteString(s)
 }
 
 func (ib *invertibleBuffer) Write(bs []byte) (int, error) {
         if ib.invert {
                 ib.Grow(len(bs))
                 for i, b := range bs {
-                        if err := ib.Buffer.WriteByte(b ^ 0xFF); err != nil {
+                        if err := ib.WriteBuffer.WriteByte(b ^ 0xFF); err != nil {
                                 return i, err
                         }
                 }
                 return len(bs), nil
         }
-        return ib.Buffer.Write(bs)
+        return ib.WriteBuffer.Write(bs)
 }
 
 func (ib *invertibleBuffer) WriteByte(b byte) error {
         if ib.invert {
                 b = b ^ 0xFF
         }
-        return ib.Buffer.WriteByte(b)
+        return ib.WriteBuffer.WriteByte(b)
 }
 
 func (ib *invertibleBuffer) ReadByte() (byte, error) {
-        ret, err := ib.Buffer.ReadByte()
+        ret, err := ib.WriteBuffer.ReadByte()
         if ib.invert {
                 ret = ret ^ 0xFF
         }
         return ret, err
 }
 
 func (ib *invertibleBuffer) SetInvert(inverted bool) {
         ib.invert = inverted
 }