Add v2 of BSON encoder and decoder framework

GODRIVER-494
GODRIVER-495
GODRIVER-496
GODRIVER-497
GODRIVER-498
GODRIVER-499
GODRIVER-500
GODRIVER-501
GODRIVER-516

Change-Id: Ib28a1b564846438ab0f3f9c95c70cea1cb48c8fa

Author: skriptble

bson/array.go

@@ -71,6 +71,12 @@ func (a *Array) Validate() (uint32, error) {
 }
 
 // Lookup returns the value in the array at the given index or an error if it cannot be found.
+//
+// TODO: We should fix this to align with the semantics of the *Document type,
+// e.g. have Lookup return just a *Value or panic if it's out of bounds and have
+// a LookupOK that returns a bool. Although if we want to align with the
+// semantics of how Go arrays and slices work, we would not provide a LookupOK
+// and force users to use the Len method before hand to avoid panics.
 func (a *Array) Lookup(index uint) (*Value, error) {
 	v, ok := a.doc.ElementAtOK(index)
 	if !ok {
@@ -334,3 +340,8 @@ func (a *Array) MarshalBSON() ([]byte, error) {
 func (a *Array) Iterator() (*ArrayIterator, error) {
 	return NewArrayIterator(a)
 }
+
+// Equal compares this document to another, returning true if they are equal.
+func (a *Array) Equal(a2 *Array) bool {
+	return a.doc.Equal(a2.doc)
+}

bson/array_iterator.go

@@ -22,6 +22,10 @@ func NewArrayIterator(array *Array) (*ArrayIterator, error) {
 	return iter, nil
 }
 
+func newArrayIterator(a *Array) *ArrayIterator {
+	return &ArrayIterator{array: a}
+}
+
 // Next fetches the next value in the Array, returning whether or not it could be fetched successfully. If true is
 // returned, call Value to get the value. If false is returned, call Err to check if an error occurred.
 func (iter *ArrayIterator) Next() bool {

bson/benchmark_test.go

@@ -0,0 +1,166 @@
+package bson
+
+import "testing"
+
+type encodetest struct {
+	Field1String  string
+	Field1Int64   int64
+	Field1Float64 float64
+	Field2String  string
+	Field2Int64   int64
+	Field2Float64 float64
+	Field3String  string
+	Field3Int64   int64
+	Field3Float64 float64
+	Field4String  string
+	Field4Int64   int64
+	Field4Float64 float64
+}
+
+type nestedtest1 struct {
+	Nested nestedtest2
+}
+
+type nestedtest2 struct {
+	Nested nestedtest3
+}
+
+type nestedtest3 struct {
+	Nested nestedtest4
+}
+
+type nestedtest4 struct {
+	Nested nestedtest5
+}
+
+type nestedtest5 struct {
+	Nested nestedtest6
+}
+
+type nestedtest6 struct {
+	Nested nestedtest7
+}
+
+type nestedtest7 struct {
+	Nested nestedtest8
+}
+
+type nestedtest8 struct {
+	Nested nestedtest9
+}
+
+type nestedtest9 struct {
+	Nested nestedtest10
+}
+
+type nestedtest10 struct {
+	Nested nestedtest11
+}
+
+type nestedtest11 struct {
+	Nested encodetest
+}
+
+var encodetestInstance = encodetest{
+	Field1String:  "foo",
+	Field1Int64:   1,
+	Field1Float64: 3.0,
+	Field2String:  "bar",
+	Field2Int64:   2,
+	Field2Float64: 3.1,
+	Field3String:  "baz",
+	Field3Int64:   3,
+	Field3Float64: 3.14,
+	Field4String:  "qux",
+	Field4Int64:   4,
+	Field4Float64: 3.141,
+}
+
+var nestedInstance = nestedtest1{
+	nestedtest2{
+		nestedtest3{
+			nestedtest4{
+				nestedtest5{
+					nestedtest6{
+						nestedtest7{
+							nestedtest8{
+								nestedtest9{
+									nestedtest10{
+										nestedtest11{
+											encodetest{
+												Field1String:  "foo",
+												Field1Int64:   1,
+												Field1Float64: 3.0,
+												Field2String:  "bar",
+												Field2Int64:   2,
+												Field2Float64: 3.1,
+												Field3String:  "baz",
+												Field3Int64:   3,
+												Field3Float64: 3.14,
+												Field4String:  "qux",
+												Field4Int64:   4,
+												Field4Float64: 3.141,
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+}
+
+func BenchmarkEncodingv1(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = Marshal(encodetestInstance)
+	}
+}
+
+func BenchmarkEncodingv2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = Marshalv2(encodetestInstance)
+	}
+}
+
+func BenchmarkEncodingv2ToDocument(b *testing.B) {
+	var buf []byte
+	for i := 0; i < b.N; i++ {
+		buf, _ = Marshalv2(encodetestInstance)
+		_, _ = ReadDocument(buf)
+	}
+}
+
+func BenchmarkEncodingDocument(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = MarshalDocument(encodetestInstance)
+	}
+}
+
+func BenchmarkEncodingv1Nested(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = Marshal(nestedInstance)
+	}
+}
+
+func BenchmarkEncodingv2Nested(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = Marshalv2(nestedInstance)
+	}
+}
+
+func BenchmarkEncodingv2ToDocumentNested(b *testing.B) {
+	var buf []byte
+	for i := 0; i < b.N; i++ {
+		buf, _ = Marshalv2(nestedInstance)
+		_, _ = ReadDocument(buf)
+	}
+}
+
+func BenchmarkEncodingDocumentNested(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = MarshalDocument(nestedInstance)
+	}
+}

bson/bson.go

@@ -16,3 +16,10 @@ package bson
 // `data[n[1]:]`. Since there is no value end byte, an unvalidated document
 // could result in parsing errors.
 type node [2]uint32
+
+// Zeroer allows custom struct types to implement a report of zero
+// state. All struct types that don't implement Zeroer or where IsZero
+// returns false are considered to be not zero.
+type Zeroer interface {
+	IsZero() bool
+}

bson/bson_test.go

@@ -7,8 +7,10 @@
 package bson
 
 import (
+	"bytes"
 	"encoding/binary"
 	"math"
+	"reflect"
 	"testing"
 	"time"
 
@@ -129,3 +131,40 @@ func TestTimeRoundTrip(t *testing.T) {
 	assert.True(t, rtval.Value.IsZero())
 
 }
+
+func TestBasicEncode(t *testing.T) {
+	for _, tc := range marshalingTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := make(writer, 0, 1024)
+			vw := newValueWriter(&got)
+			reg := NewRegistryBuilder().Build()
+			codec, err := reg.Lookup(reflect.TypeOf(tc.val))
+			noerr(t, err)
+			err = codec.EncodeValue(EncodeContext{Registry: reg}, vw, tc.val)
+			noerr(t, err)
+
+			if !bytes.Equal(got, tc.want) {
+				t.Errorf("Bytes are not equal. got %v; want %v", Reader(got), Reader(tc.want))
+				t.Errorf("Bytes:\n%v\n%v", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestBasicDecode(t *testing.T) {
+	for _, tc := range unmarshalingTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := reflect.New(tc.sType).Interface()
+			vr := newValueReader(tc.data)
+			reg := NewRegistryBuilder().Build()
+			codec, err := reg.Lookup(reflect.TypeOf(got))
+			noerr(t, err)
+			err = codec.DecodeValue(DecodeContext{Registry: reg}, vr, got)
+			noerr(t, err)
+
+			if !reflect.DeepEqual(got, tc.want) {
+				t.Errorf("Results do not match. got %+v; want %+v", got, tc.want)
+			}
+		})
+	}
+}