GODRIVER-1294 support marshaling interfaces to bson (#206)

Author: iwysiu

bson/bsoncodec/default_value_encoders.go

@@ -289,8 +289,9 @@ func (dve DefaultValueEncoders) MapEncodeValue(ec EncodeContext, vw bsonrw.Value
 // struct codec.
 func (dve DefaultValueEncoders) mapEncodeValue(ec EncodeContext, dw bsonrw.DocumentWriter, val reflect.Value, collisionFn func(string) bool) error {
 
-	encoder, err := ec.LookupEncoder(val.Type().Elem())
-	if err != nil {
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
 		return err
 	}
 
@@ -299,19 +300,25 @@ func (dve DefaultValueEncoders) mapEncodeValue(ec EncodeContext, dw bsonrw.Docum
 		if collisionFn != nil && collisionFn(key.String()) {
 			return fmt.Errorf("Key %s of inlined map conflicts with a struct field name", key)
 		}
+
+		currEncoder, currVal, err := dve.lookupElementEncoder(ec, encoder, val.MapIndex(key))
+		if err != nil {
+			return err
+		}
+
 		vw, err := dw.WriteDocumentElement(key.String())
 		if err != nil {
 			return err
 		}
 
-		if enc, ok := encoder.(ValueEncoder); ok {
-			err = enc.EncodeValue(ec, vw, val.MapIndex(key))
+		if enc, ok := currEncoder.(ValueEncoder); ok {
+			err = enc.EncodeValue(ec, vw, currVal)
 			if err != nil {
 				return err
 			}
 			continue
 		}
-		err = encoder.EncodeValue(ec, vw, val.MapIndex(key))
+		err = encoder.EncodeValue(ec, vw, currVal)
 		if err != nil {
 			return err
 		}
@@ -349,18 +356,24 @@ func (dve DefaultValueEncoders) ArrayEncodeValue(ec EncodeContext, vw bsonrw.Val
 		return err
 	}
 
-	encoder, err := ec.LookupEncoder(val.Type().Elem())
-	if err != nil {
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
 		return err
 	}
 
 	for idx := 0; idx < val.Len(); idx++ {
+		currEncoder, currVal, err := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
+		if err != nil {
+			return err
+		}
+
 		vw, err := aw.WriteArrayElement()
 		if err != nil {
 			return err
 		}
 
-		err = encoder.EncodeValue(ec, vw, val.Index(idx))
+		err = currEncoder.EncodeValue(ec, vw, currVal)
 		if err != nil {
 			return err
 		}
@@ -402,25 +415,44 @@ func (dve DefaultValueEncoders) SliceEncodeValue(ec EncodeContext, vw bsonrw.Val
 		return err
 	}
 
-	encoder, err := ec.LookupEncoder(val.Type().Elem())
-	if err != nil {
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
 		return err
 	}
 
 	for idx := 0; idx < val.Len(); idx++ {
+		currEncoder, currVal, err := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
+		if err != nil {
+			return err
+		}
+
 		vw, err := aw.WriteArrayElement()
 		if err != nil {
 			return err
 		}
 
-		err = encoder.EncodeValue(ec, vw, val.Index(idx))
+		err = currEncoder.EncodeValue(ec, vw, currVal)
 		if err != nil {
 			return err
 		}
 	}
 	return aw.WriteArrayEnd()
 }
 
+func (dve DefaultValueEncoders) lookupElementEncoder(ec EncodeContext, origEncoder ValueEncoder, currVal reflect.Value) (ValueEncoder, reflect.Value, error) {
+	if origEncoder != nil || (currVal.Kind() != reflect.Interface) {
+		return origEncoder, currVal, nil
+	}
+	currVal = currVal.Elem()
+	if !currVal.IsValid() {
+		return nil, currVal, fmt.Errorf("cannot encode invalid element")
+	}
+	currEncoder, err := ec.LookupEncoder(currVal.Type())
+
+	return currEncoder, currVal, err
+}
+
 // EmptyInterfaceEncodeValue is the ValueEncoderFunc for interface{}.
 func (dve DefaultValueEncoders) EmptyInterfaceEncodeValue(ec EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error {
 	if !val.IsValid() || val.Type() != tEmpty {

bson/bsoncodec/default_value_encoders_test.go

@@ -24,6 +24,18 @@ import (
 	"math"
 )
 
+type myInterface interface {
+	Foo() int
+}
+
+type myStruct struct {
+	Val int
+}
+
+func (ms myStruct) Foo() int {
+	return ms.Val
+}
+
 func TestDefaultValueEncoders(t *testing.T) {
 	var dve DefaultValueEncoders
 	var wrong = func(string, string) string { return "wrong" }
@@ -237,11 +249,11 @@ func TestDefaultValueEncoders(t *testing.T) {
 				},
 				{
 					"Lookup Error",
-					map[string]interface{}{},
+					map[string]interface{}{"foo": nil},
 					&EncodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.WriteDocument,
-					ErrNoEncoder{Type: reflect.TypeOf((*interface{})(nil)).Elem()},
+					fmt.Errorf("cannot encode invalid element"),
 				},
 				{
 					"WriteDocumentElement Error",
@@ -259,6 +271,22 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteString,
 					errors.New("ev error"),
 				},
+				{
+					"empty map/success",
+					map[string]interface{}{},
+					&EncodeContext{Registry: NewRegistryBuilder().Build()},
+					&bsonrwtest.ValueReaderWriter{},
+					bsonrwtest.WriteDocumentEnd,
+					nil,
+				},
+				{
+					"with interface/success",
+					map[string]myInterface{"foo": myStruct{1}},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteDocumentEnd,
+					nil,
+				},
 			},
 		},
 		{
@@ -287,7 +315,7 @@ func TestDefaultValueEncoders(t *testing.T) {
 					&EncodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.WriteArray,
-					ErrNoEncoder{Type: reflect.TypeOf((*interface{})(nil)).Elem()},
+					fmt.Errorf("cannot encode invalid element"),
 				},
 				{
 					"WriteArrayElement Error",
@@ -321,6 +349,14 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteDocumentEnd,
 					nil,
 				},
+				{
+					"[1]interface/success",
+					[1]myInterface{myStruct{1}},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteArrayEnd,
+					nil,
+				},
 			},
 		},
 		{
@@ -345,11 +381,11 @@ func TestDefaultValueEncoders(t *testing.T) {
 				},
 				{
 					"Lookup Error",
-					[]interface{}{},
+					[]interface{}{nil},
 					&EncodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.WriteArray,
-					ErrNoEncoder{Type: reflect.TypeOf((*interface{})(nil)).Elem()},
+					fmt.Errorf("cannot encode invalid element"),
 				},
 				{
 					"WriteArrayElement Error",
@@ -383,6 +419,22 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteDocumentEnd,
 					nil,
 				},
+				{
+					"empty slice/success",
+					[]interface{}{},
+					&EncodeContext{Registry: NewRegistryBuilder().Build()},
+					&bsonrwtest.ValueReaderWriter{},
+					bsonrwtest.WriteArrayEnd,
+					nil,
+				},
+				{
+					"interface/success",
+					[]myInterface{myStruct{1}},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteArrayEnd,
+					nil,
+				},
 			},
 		},
 		{
@@ -871,6 +923,20 @@ func TestDefaultValueEncoders(t *testing.T) {
 				},
 			},
 		},
+		{
+			"StructEncodeValue",
+			defaultStructCodec,
+			[]subtest{
+				{
+					"interface value",
+					struct{ Foo myInterface }{Foo: myStruct{1}},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteDocumentEnd,
+					nil,
+				},
+			},
+		},
 		{
 			"CodeWithScopeEncodeValue",
 			ValueEncoderFunc(dve.CodeWithScopeEncodeValue),

bson/bsoncodec/struct_codec.go

@@ -74,6 +74,8 @@ func (sc *StructCodec) EncodeValue(r EncodeContext, vw bsonrw.ValueWriter, val r
 			rv = val.FieldByIndex(desc.inline)
 		}
 
+		desc.encoder, rv, err = defaultValueEncoders.lookupElementEncoder(r, desc.encoder, rv)
+
 		if desc.encoder == nil {
 			return ErrNoEncoder{Type: rv.Type()}
 		}