Update codec system to use reflect.Value

Add support for pointers to the BSON codec system. When doing an
interface lookup for a decoder, we now check if the type or a pointer to
the type implement the interface. If either one does, we return the
decoder for that interface.

This change changes the ValueEncoder and ValueDecoder interfaces to use
reflect.Value instead of interface{}.

Move the bson.D family of types into the primitive package.

GODRIVER-535
GODRIVER-598
GODRIVER-588
GODRIVER-645
GODRIVER-662
GODRIVER-649
GODRIVER-670

Change-Id: Idec68f74e354973160bd59f9f8fef009f026f943

Author: skriptble

bson/bson.go

@@ -13,6 +13,8 @@ import (
 	"math"
 	"strconv"
 	"strings"
+
+	"github.com/mongodb/mongo-go-driver/bson/primitive"
 )
 
 // Zeroer allows custom struct types to implement a report of zero
@@ -32,22 +34,7 @@ type Zeroer interface {
 //
 // This type should be used in situations where order matters, such as MongoDB commands. If the
 // order is not important, a map is more comfortable and concise.
-type D []E
-
-// Map creates a map from the elements of the D.
-func (d D) Map() M {
-	m := make(M, len(d))
-	for _, e := range d {
-		m[e.Key] = e.Value
-	}
-	return m
-}
-
-// E represents a BSON element for a D. It is usually used inside a D.
-type E struct {
-	Key   string
-	Value interface{}
-}
+type D = primitive.D
 
 // M is an unordered, concise representation of a BSON Document. It should generally be used to
 // serialize BSON when the order of the elements of a BSON document do not matter. If the element
@@ -59,7 +46,7 @@ type E struct {
 //
 // This type is handled in the encoders as a regular map[string]interface{}. The elements will be
 // serialized in an undefined, random order, and the order will be different each time.
-type M map[string]interface{}
+type M = primitive.M
 
 // An A represents a BSON array. This type can be used to represent a BSON array in a concise and
 // readable manner. It should generally be used when serializing to BSON. For deserializing, the
@@ -69,7 +56,7 @@ type M map[string]interface{}
 //
 // 		bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
 //
-type A []interface{}
+type A = primitive.A
 
 func formatDouble(f float64) string {
 	var s string

bson/bson_corpus_spec_test.go

@@ -13,6 +13,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"path"
+	"reflect"
 	"strconv"
 	"strings"
 	"testing"
@@ -61,7 +62,7 @@ type parseErrorTestCase struct {
 
 const dataDir = "../data"
 
-var pc PrimitiveCodecs
+var pc bsonx.PrimitiveCodecs
 var dvd bsoncodec.DefaultValueDecoders
 var dve bsoncodec.DefaultValueEncoders
 
@@ -163,10 +164,10 @@ func normalizeRelaxedDouble(t *testing.T, key string, rEJ string) string {
 
 // bsonToNative decodes the BSON bytes (b) into a native Document
 func bsonToNative(t *testing.T, b []byte, bType, testDesc string) bsonx.Doc {
-	var doc bsonx.Doc
-	err := pc.x.DocumentDecodeValue(dc, bsonrw.NewBSONDocumentReader(b), &doc)
+	doc := reflect.New(reflect.TypeOf(bsonx.Doc{})).Elem()
+	err := pc.DocumentDecodeValue(dc, bsonrw.NewBSONDocumentReader(b), doc)
 	expectNoError(t, err, fmt.Sprintf("%s: decoding %s BSON", testDesc, bType))
-	return doc
+	return doc.Interface().(bsonx.Doc)
 }
 
 // nativeToBSON encodes the native Document (doc) into canonical BSON and compares it to the expected
@@ -175,7 +176,7 @@ func nativeToBSON(t *testing.T, cB []byte, doc bsonx.Doc, testDesc, bType, docSr
 	actualB := new(bytes.Buffer)
 	vw, err := bsonrw.NewBSONValueWriter(actualB)
 	expectNoError(t, err, fmt.Sprintf("%s: creating ValueWriter", testDesc))
-	err = pc.x.DocumentEncodeValue(ec, vw, doc)
+	err = pc.DocumentEncodeValue(ec, vw, reflect.ValueOf(doc))
 	expectNoError(t, err, fmt.Sprintf("%s: encoding %s BSON", testDesc, bType))
 
 	if diff := cmp.Diff(cB, actualB.Bytes()); diff != "" {
@@ -299,8 +300,8 @@ func runTest(t *testing.T, file string) {
 			b, err := hex.DecodeString(d.Bson)
 			expectNoError(t, err, d.Description)
 
-			var doc bsonx.Doc
-			err = pc.x.DocumentDecodeValue(dc, bsonrw.NewBSONDocumentReader(b), &doc)
+			doc := reflect.New(reflect.TypeOf(bsonx.Doc{})).Elem()
+			err = pc.DocumentDecodeValue(dc, bsonrw.NewBSONDocumentReader(b), doc)
 			expectError(t, err, fmt.Sprintf("%s: expected decode error", d.Description))
 		}
 

bson/bsoncodec/bsoncodec.go

@@ -8,6 +8,7 @@ package bsoncodec
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 
 	"github.com/mongodb/mongo-go-driver/bson/bsonrw"
@@ -45,36 +46,60 @@ type ValueUnmarshaler interface {
 	UnmarshalBSONValue(bsontype.Type, []byte) error
 }
 
-// ValueEncoderError is an error returned from a ValueEncoder when the provided
-// value can't be encoded by the ValueEncoder.
+// ValueEncoderError is an error returned from a ValueEncoder when the provided value can't be
+// encoded by the ValueEncoder.
 type ValueEncoderError struct {
 	Name     string
-	Types    []interface{}
-	Received interface{}
+	Types    []reflect.Type
+	Kinds    []reflect.Kind
+	Received reflect.Value
 }
 
 func (vee ValueEncoderError) Error() string {
-	types := make([]string, 0, len(vee.Types))
+	typeKinds := make([]string, 0, len(vee.Types)+len(vee.Kinds))
 	for _, t := range vee.Types {
-		types = append(types, fmt.Sprintf("%T", t))
+		typeKinds = append(typeKinds, t.String())
 	}
-	return fmt.Sprintf("%s can only process %s, but got a %T", vee.Name, strings.Join(types, ", "), vee.Received)
+	for _, k := range vee.Kinds {
+		if k == reflect.Map {
+			typeKinds = append(typeKinds, "map[string]*")
+			continue
+		}
+		typeKinds = append(typeKinds, k.String())
+	}
+	received := vee.Received.Kind().String()
+	if vee.Received.IsValid() {
+		received = vee.Received.Type().String()
+	}
+	return fmt.Sprintf("%s can only encode valid %s, but got %s", vee.Name, strings.Join(typeKinds, ", "), received)
 }
 
-// ValueDecoderError is an error returned from a ValueDecoder when the provided
-// value can't be decoded by the ValueDecoder.
+// ValueDecoderError is an error returned from a ValueDecoder when the provided value can't be
+// decoded by the ValueDecoder.
 type ValueDecoderError struct {
 	Name     string
-	Types    []interface{}
-	Received interface{}
+	Types    []reflect.Type
+	Kinds    []reflect.Kind
+	Received reflect.Value
 }
 
 func (vde ValueDecoderError) Error() string {
-	types := make([]string, 0, len(vde.Types))
+	typeKinds := make([]string, 0, len(vde.Types)+len(vde.Kinds))
 	for _, t := range vde.Types {
-		types = append(types, fmt.Sprintf("%T", t))
+		typeKinds = append(typeKinds, t.String())
+	}
+	for _, k := range vde.Kinds {
+		if k == reflect.Map {
+			typeKinds = append(typeKinds, "map[string]*")
+			continue
+		}
+		typeKinds = append(typeKinds, k.String())
+	}
+	received := vde.Received.Kind().String()
+	if vde.Received.IsValid() {
+		received = vde.Received.Type().String()
 	}
-	return fmt.Sprintf("%s can only process %s, but got a %T", vde.Name, strings.Join(types, ", "), vde.Received)
+	return fmt.Sprintf("%s can only decode valid and settable %s, but got %s", vde.Name, strings.Join(typeKinds, ", "), received)
 }
 
 // EncodeContext is the contextual information required for a Codec to encode a
@@ -98,36 +123,31 @@ type ValueCodec interface {
 	ValueDecoder
 }
 
-// ValueEncoder is the interface implemented by types that can handle the
-// encoding of a value. Implementations must handle both values and
-// pointers to values.
+// ValueEncoder is the interface implemented by types that can handle the encoding of a value.
 type ValueEncoder interface {
-	EncodeValue(EncodeContext, bsonrw.ValueWriter, interface{}) error
+	EncodeValue(EncodeContext, bsonrw.ValueWriter, reflect.Value) error
 }
 
-// ValueEncoderFunc is an adapter function that allows a function with the
-// correct signature to be used as a ValueEncoder.
-type ValueEncoderFunc func(EncodeContext, bsonrw.ValueWriter, interface{}) error
+// ValueEncoderFunc is an adapter function that allows a function with the correct signature to be
+// used as a ValueEncoder.
+type ValueEncoderFunc func(EncodeContext, bsonrw.ValueWriter, reflect.Value) error
 
 // EncodeValue implements the ValueEncoder interface.
-func (fn ValueEncoderFunc) EncodeValue(ec EncodeContext, vw bsonrw.ValueWriter, val interface{}) error {
+func (fn ValueEncoderFunc) EncodeValue(ec EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error {
 	return fn(ec, vw, val)
 }
 
-// ValueDecoder is the interface implemented by types that can handle the
-// decoding of a value. Implementations must handle pointers to values,
-// including pointers to pointer values. The implementation may create a new
-// value and assign it to the pointer if necessary.
+// ValueDecoder is the interface implemented by types that can handle the decoding of a value.
 type ValueDecoder interface {
-	DecodeValue(DecodeContext, bsonrw.ValueReader, interface{}) error
+	DecodeValue(DecodeContext, bsonrw.ValueReader, reflect.Value) error
 }
 
-// ValueDecoderFunc is an adapter function that allows a function with the
-// correct signature to be used as a ValueDecoder.
-type ValueDecoderFunc func(DecodeContext, bsonrw.ValueReader, interface{}) error
+// ValueDecoderFunc is an adapter function that allows a function with the correct signature to be
+// used as a ValueDecoder.
+type ValueDecoderFunc func(DecodeContext, bsonrw.ValueReader, reflect.Value) error
 
 // DecodeValue implements the ValueDecoder interface.
-func (fn ValueDecoderFunc) DecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val interface{}) error {
+func (fn ValueDecoderFunc) DecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
 	return fn(dc, vr, val)
 }
 

bson/bsoncodec/bsoncodec_test.go

@@ -91,22 +91,16 @@ func (llc *llCodec) EncodeValue(_ EncodeContext, _ bsonrw.ValueWriter, i interfa
 	return nil
 }
 
-func (llc *llCodec) DecodeValue(_ DecodeContext, _ bsonrw.ValueReader, i interface{}) error {
+func (llc *llCodec) DecodeValue(_ DecodeContext, _ bsonrw.ValueReader, val reflect.Value) error {
 	if llc.err != nil {
 		return llc.err
 	}
 
-	val := reflect.ValueOf(i)
-	if val.Type().Kind() != reflect.Ptr {
-		llc.t.Errorf("Value provided to DecodeValue must be a pointer, but got %T", i)
+	if !reflect.TypeOf(llc.decodeval).AssignableTo(val.Type()) {
+		llc.t.Errorf("decodeval must be assignable to val provided to DecodeValue, but is not. decodeval %T; val %T", llc.decodeval, val)
 		return nil
 	}
 
-	if !reflect.TypeOf(llc.decodeval).AssignableTo(val.Type().Elem()) {
-		llc.t.Errorf("decodeval must be assignable to i provided to DecodeValue, but is not. decodeval %T; i %T", llc.decodeval, i)
-		return nil
-	}
-
-	val.Elem().Set(reflect.ValueOf(llc.decodeval))
+	val.Set(reflect.ValueOf(llc.decodeval))
 	return nil
 }