Merge pull request globalsign#54 from joomcode/feature/primitive-5

INFRA-4180: Replace custom marshaling interfaces

Author: bozaro

bson/bson.go

@@ -93,16 +93,25 @@ const (
 	BinaryUserDefined = bsontype.BinaryUserDefined
 )
 
+// deprecated
+//
+// Use bson.ValueMarshaler
+//
 // Getter interface: a value implementing the bson.Getter interface will have its GetBSON
 // method called when the given value has to be marshalled, and the result
 // of this method will be marshaled in place of the actual object.
 //
 // If GetBSON returns return a non-nil error, the marshalling procedure
 // will stop and error out with the provided value.
 type Getter interface {
+	// deprecated
 	GetBSON() (interface{}, error)
 }
 
+// deprecated
+//
+// Use bson.ValueUnmarshaler
+//
 // Setter interface: a value implementing the bson.Setter interface will receive the BSON
 // value via the SetBSON method during unmarshaling, and the object
 // itself will not be changed as usual.
@@ -131,6 +140,7 @@ type Getter interface {
 //     }
 //
 type Setter interface {
+	// deprecated
 	SetBSON(raw Raw) error
 }
 

bson/bson_test.go

@@ -39,9 +39,9 @@ import (
 	"testing"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-
 	"github.com/joomcode/mgo/bson"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
 	. "gopkg.in/check.v1"
 )
 
@@ -462,15 +462,19 @@ func (s *S) Test64bitInt(c *C) {
 type prefixPtr string
 type prefixVal string
 
-func (t *prefixPtr) GetBSON() (interface{}, error) {
+func (t *prefixPtr) MarshalBSONValue() (bsontype.Type, []byte, error) {
 	if t == nil {
-		return nil, nil
+		return bsontype.Null, nil, nil
 	}
-	return "foo-" + string(*t), nil
+	return bsontype.String, bsoncore.AppendString(nil, "foo-"+string(*t)), nil
 }
 
-func (t *prefixPtr) SetBSON(raw bson.Raw) error {
+func (t *prefixPtr) UnmarshalBSONValue(btype bsontype.Type, data []byte) error {
 	var s string
+	raw := bson.Raw{
+		Type:  btype,
+		Value: data,
+	}
 	if raw.Type == 0x0A {
 		return bson.ErrSetZero
 	}
@@ -484,12 +488,16 @@ func (t *prefixPtr) SetBSON(raw bson.Raw) error {
 	return nil
 }
 
-func (t prefixVal) GetBSON() (interface{}, error) {
-	return "foo-" + string(t), nil
+func (t prefixVal) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bsontype.String, bsoncore.AppendString(nil, "foo-"+string(t)), nil
 }
 
-func (t *prefixVal) SetBSON(raw bson.Raw) error {
+func (t *prefixVal) UnmarshalBSONValue(btype bsontype.Type, data []byte) error {
 	var s string
+	raw := bson.Raw{
+		Type:  btype,
+		Value: data,
+	}
 	if raw.Type == 0x0A {
 		return bson.ErrSetZero
 	}
@@ -902,8 +910,8 @@ type setterType struct {
 	received interface{}
 }
 
-func (o *setterType) SetBSON(raw bson.Raw) error {
-	err := bson.RawUnmarshal(raw, &o.received)
+func (o *setterType) UnmarshalBSONValue(btype bsontype.Type, data []byte) error {
+	err := bson.RawUnmarshal(bson.Raw{Type: btype, Value: data}, &o.received)
 	if err != nil {
 		panic("The panic:" + err.Error())
 	}
@@ -1032,11 +1040,21 @@ type typeWithGetter struct {
 	err    error
 }
 
-func (t *typeWithGetter) GetBSON() (interface{}, error) {
+func (t *typeWithGetter) MarshalBSONValue() (bsontype.Type, []byte, error) {
 	if t == nil {
-		return "<value is nil>", nil
+		return bsontype.String, bsoncore.AppendString(nil, "<value is nil>"), nil
+	}
+
+	doc, err := bson.Marshal(struct {
+		V interface{} `bson:"v"`
+	}{
+		V: t.result,
+	})
+	if err != nil {
+		panic(err)
 	}
-	return t.result, t.err
+	element, _, _ := bsoncore.ReadElement(doc[4:])
+	return element.Value().Type, element.Value().Data, t.err
 }
 
 type docWithGetterField struct {
@@ -1081,8 +1099,8 @@ func (s *S) TestGetterErrors(c *C) {
 
 type intGetter int64
 
-func (t intGetter) GetBSON() (interface{}, error) {
-	return int64(t), nil
+func (t intGetter) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bsontype.Int32, bsoncore.AppendInt32(nil, int32(t)), nil
 }
 
 type typeWithIntGetter struct {
@@ -1226,30 +1244,46 @@ type unexported struct {
 
 type getterSetterD bson.D
 
-func (s getterSetterD) GetBSON() (interface{}, error) {
-	if len(s) == 0 {
-		return bson.D{}, nil
+func (s getterSetterD) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	var d bson.D
+	if len(s) != 0 {
+		d = bson.D(s[:len(s)-1])
+	}
+	data, err := bson.Marshal(d)
+	if err != nil {
+		panic(err)
 	}
-	return bson.D(s[:len(s)-1]), nil
+	return bsontype.EmbeddedDocument, data, nil
 }
 
-func (s *getterSetterD) SetBSON(raw bson.Raw) error {
+func (s *getterSetterD) UnmarshalBSONValue(btype bsontype.Type, data []byte) error {
 	var doc bson.D
-	err := bson.RawUnmarshal(raw, &doc)
+	err := bson.RawUnmarshal(bson.Raw{
+		Type:  btype,
+		Value: data,
+	}, &doc)
 	doc = append(doc, bson.DocElem{Key: "suffix", Value: true})
 	*s = getterSetterD(doc)
 	return err
 }
 
 type getterSetterInt int
 
-func (i getterSetterInt) GetBSON() (interface{}, error) {
-	return bson.D{{Key: "a", Value: int(i)}}, nil
+func (i getterSetterInt) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	d := bson.D{{Key: "a", Value: int(i)}}
+	data, err := bson.Marshal(d)
+	if err != nil {
+		panic(err)
+	}
+	return bsontype.EmbeddedDocument, data, nil
 }
 
-func (i *getterSetterInt) SetBSON(raw bson.Raw) error {
+func (i *getterSetterInt) UnmarshalBSONValue(btype bsontype.Type, data []byte) error {
 	var doc struct{ A int }
-	err := bson.RawUnmarshal(raw, &doc)
+	err := bson.RawUnmarshal(bson.Raw{
+		Type:  btype,
+		Value: data,
+	}, &doc)
 	*i = getterSetterInt(doc.A)
 	return err
 }
@@ -1260,17 +1294,24 @@ type ifaceType interface {
 
 type ifaceSlice []ifaceType
 
-func (s *ifaceSlice) SetBSON(raw bson.Raw) error {
+func (s *ifaceSlice) UnmarshalBSONValue(btype bsontype.Type, data []byte) error {
 	var ns []int
-	if err := bson.RawUnmarshal(raw, &ns); err != nil {
+	if err := bson.RawUnmarshal(bson.Raw{
+		Type:  btype,
+		Value: data,
+	}, &ns); err != nil {
 		return err
 	}
 	*s = make(ifaceSlice, ns[0])
 	return nil
 }
 
-func (s ifaceSlice) GetBSON() (interface{}, error) {
-	return []int{len(s)}, nil
+func (s ifaceSlice) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	var data []byte
+	idx, data := bsoncore.AppendArrayStart(data)
+	data = bsoncore.AppendInt32Element(data, "1", int32(len(s)))
+	data, _ = bsoncore.AppendArrayEnd(data, idx)
+	return bsontype.Array, data, nil
 }
 
 type omitEmptyAware struct {

bson/decode.go

@@ -38,6 +38,7 @@ import (
 	"sync"
 	"time"
 
+	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
@@ -72,12 +73,15 @@ const (
 )
 
 var setterStyles map[reflect.Type]int
-var setterIface reflect.Type
+var setterIfaceLegacy reflect.Type
+var setterIfaceHipster reflect.Type
 var setterMutex sync.RWMutex
 
 func init() {
-	var iface Setter
-	setterIface = reflect.TypeOf(&iface).Elem()
+	var ifaceLegacy Setter
+	var ifaceHipster bson.ValueUnmarshaler
+	setterIfaceLegacy = reflect.TypeOf(&ifaceLegacy).Elem()
+	setterIfaceHipster = reflect.TypeOf(&ifaceHipster).Elem()
 	setterStyles = make(map[reflect.Type]int)
 }
 
@@ -91,18 +95,22 @@ func setterStyle(outt reflect.Type) int {
 
 	setterMutex.Lock()
 	defer setterMutex.Unlock()
-	if outt.Implements(setterIface) {
+	if outt.Implements(setterIfaceHipster) {
 		style = setterType
-	} else if reflect.PtrTo(outt).Implements(setterIface) {
+	} else if reflect.PtrTo(outt).Implements(setterIfaceHipster) {
 		style = setterAddr
+	} else if outt.Implements(setterIfaceLegacy) {
+		panic(fmt.Errorf("Type %q implements %q but not implements %q", outt.String(), setterIfaceLegacy.String(), setterIfaceHipster.String()))
+	} else if reflect.PtrTo(outt).Implements(setterIfaceLegacy) {
+		panic(fmt.Errorf("Type %q implements %q but not implements %q", outt.String(), setterIfaceLegacy.String(), setterIfaceHipster.String()))
 	} else {
 		style = setterNone
 	}
 	setterStyles[outt] = style
 	return style
 }
 
-func getSetter(outt reflect.Type, out reflect.Value) Setter {
+func getSetter(outt reflect.Type, out reflect.Value) bson.ValueUnmarshaler {
 	style := setterStyle(outt)
 	if style == setterNone {
 		return nil
@@ -115,7 +123,7 @@ func getSetter(outt reflect.Type, out reflect.Value) Setter {
 	} else if outt.Kind() == reflect.Ptr && out.IsNil() {
 		out.Set(reflect.New(outt.Elem()))
 	}
-	return out.Interface().(Setter)
+	return out.Interface().(bson.ValueUnmarshaler)
 }
 
 func clearMap(m reflect.Value) {
@@ -136,7 +144,7 @@ func (d *decoder) readDocTo(out reflect.Value) {
 		}
 		if setter := getSetter(outt, out); setter != nil {
 			raw := d.readRaw(ElementDocument)
-			err := setter.SetBSON(raw)
+			err := setter.UnmarshalBSONValue(raw.Type, raw.Value)
 			if _, ok := err.(*TypeError); err != nil && !ok {
 				panic(err)
 			}
@@ -663,7 +671,8 @@ func (d *decoder) readElemTo(out reflect.Value, kind bsontype.Type) (good bool)
 	}
 
 	if setter := getSetter(outt, out); setter != nil {
-		err := setter.SetBSON(d.readRaw(kind))
+		raw := d.readRaw(kind)
+		err := setter.UnmarshalBSONValue(raw.Type, raw.Value)
 		if err == ErrSetZero {
 			out.Set(reflect.Zero(outt))
 			return true