Fix issue#12

db/backend.go

@@ -39,7 +39,8 @@ func newBackend() *backend {
 }
 
 func (b *backend) getData(offset int64) []byte {
-	rec, err := b.fc.Fetch(offset)
+	rec := &recordio.Record{Data: nil}
+	err := b.fc.Fetch(offset, rec)
 	if err != nil {
 		panic("unimplemented")
 	}
@@ -87,7 +88,7 @@ func (b *backend) Put(rev int, path Path, data []byte) {
 	}
 
 	b.rev++
-	offset, err := b.ap.Append(recordio.Record{data})
+	offset, err := b.ap.Append(&recordio.Record{data})
 	if err != nil {
 		panic("unimplemented")
 	}

db/recordio/appender.go

@@ -3,7 +3,7 @@ package recordio
 import "io"
 
 type Appender interface {
-	Append(Record) (int64, error)
+	Append(Encoder) (int64, error)
 }
 
 type appender struct {
@@ -15,13 +15,13 @@ func NewAppender(w io.WriteSeeker) Appender {
 }
 
 // Not thread-safe
-func (ap *appender) Append(r Record) (offset int64, err error) {
+func (ap *appender) Append(r Encoder) (offset int64, err error) {
 	offset, err = ap.w.Seek(0, 2)
 	if err != nil {
 		return -1, err
 	}
 
-	err = (&r).encodeTo(ap.w)
+	err = r.EncodeTo(ap.w)
 	if err != nil {
 		return -1, err
 	}

db/recordio/fetcher.go

@@ -3,7 +3,7 @@ package recordio
 import "io"
 
 type Fetcher interface {
-	Fetch(offset int64) (Record, error)
+	Fetch(offset int64, d Decoder) error
 }
 
 type fetcher struct {
@@ -14,17 +14,16 @@ func NewFetcher(r io.ReadSeeker) Fetcher {
 	return &fetcher{r}
 }
 
-func (fc *fetcher) Fetch(offset int64) (Record, error) {
+func (fc *fetcher) Fetch(offset int64, d Decoder) error {
 	_, err := fc.r.Seek(offset, 0)
 	if err != nil {
-		return Record{}, err
+		return err
 	}
 
-	r := Record{}
-	err = (&r).decodeFrom(fc.r)
+	err = d.DecodeFrom(fc.r)
 	if err != nil {
-		return Record{}, err
+		return err
 	}
 
-	return r, nil
+	return nil
 }

db/recordio/io_test.go

@@ -26,10 +26,10 @@ func TestFetch(t *testing.T) {
 
 	tests := []struct {
 		offset int64
-		record Record
+		record *Record
 	}{
-		{-1, Record{[]byte("someData")}},
-		{-1, Record{[]byte("someOtherData")}},
+		{-1, &Record{[]byte("someData")}},
+		{-1, &Record{[]byte("someOtherData")}},
 	}
 
 	for i, tt := range tests {
@@ -41,7 +41,8 @@ func TestFetch(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		recRead, err := fc.Fetch(tt.offset)
+		recRead := &Record{Data: nil}
+		err := fc.Fetch(tt.offset, recRead)
 		if err != nil {
 			t.Errorf("#%d: Fetch failed: %s", i, err.Error())
 		}

db/recordio/record.go

@@ -9,11 +9,29 @@ const (
 	sizeOfLength = 4
 )
 
+// Encoder is an interface implemented by an object that can
+// encode itself into a binary representation with an io.Writer
+type Encoder interface {
+	EncodeTo(wr io.Writer) error
+}
+
+// Decoder is an interface implemented by an object that can
+// decodes itself from a binary representation provided by
+// an io.Reader
+type Decoder interface {
+	DecodeFrom(rd io.Reader) error
+}
+
+// Record is a struct that holds some binary data and can be
+// encoded into/decoded from the following binary form
+// [lenth of record]                  : 4 bytes
+// [content of record]
 type Record struct {
 	Data []byte
 }
 
-func (r *Record) encodeTo(wr io.Writer) error {
+// EncodeTo encodes a binary data in record object to an io.Writer
+func (r *Record) EncodeTo(wr io.Writer) error {
 	// Write length
 	lBuf := make([]byte, sizeOfLength)
 	binary.LittleEndian.PutUint32(lBuf, uint32(len(r.Data)))
@@ -28,7 +46,8 @@ func (r *Record) encodeTo(wr io.Writer) error {
 	return nil
 }
 
-func (r *Record) decodeFrom(rd io.Reader) error {
+// DecodeFrom decodes binary data out of io.Reader
+func (r *Record) DecodeFrom(rd io.Reader) error {
 	var length uint32
 	// Read length
 	err := binary.Read(rd, binary.LittleEndian, &length)

db/recordio/record_test.go

@@ -18,11 +18,11 @@ func TestEncodeDecode(t *testing.T) {
 		buf := new(bytes.Buffer)
 		recordToWrite := &Record{tt.data}
 
-		if err := recordToWrite.encodeTo(buf); err != nil {
+		if err := recordToWrite.EncodeTo(buf); err != nil {
 			t.Fatalf("#%d: cannot encode, err: %s", i, err)
 		}
 		recordToRead := new(Record)
-		if err := recordToRead.decodeFrom(buf); err != nil {
+		if err := recordToRead.DecodeFrom(buf); err != nil {
 			t.Fatalf("#%d: cannot decode, err: %s", i, err)
 		}
 		if !reflect.DeepEqual(recordToRead, recordToWrite) {