package main

import (
	"bytes"
	"gob"
	"log"
	"os"
)

type BlobRef struct {
	foo, bar string
}

func (br *BlobRef) String() string {
	if br == nil {
		return "<nil BlobRef>"
	}
	return br.foo + "-" + br.bar
}

func (br *BlobRef) GobEncode() ([]byte, os.Error) {
	log.Printf("GobEncode")
        return []byte(br.String()), nil
}

func (br *BlobRef) GobDecode(b []byte) os.Error {
	if br == nil {
		panic("nil receiver in GobDecode")
	}
	log.Printf("GobDecode(%q)", string(b))
	br.foo = "foo"
	br.bar = "bar"
	return nil
}

func main() {
	br := &BlobRef{"foo", "bar"}
	log.Printf("blobref String = %q", br)

	buf := new(bytes.Buffer)
	e := gob.NewEncoder(buf)
	err := e.Encode(br)
        if err != nil {
		log.Fatalf("Encode: %v", err)
        }

	d := gob.NewDecoder(buf)
        var got *BlobRef
        err = d.Decode(&got)
        if err != nil {
		log.Fatalf("Decode: %v", err)
        }
	if got == nil {
                log.Fatalf("got == nil")
        }

	if got.String() != br.String() {
                log.Fatalf("got = %q, want %q", got, br)
	}
	log.Printf("got = %q", &got)
}