update

Author: qingyang-hu

bson/bsoncodec.go

@@ -4,6 +4,29 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 
+// # ValueEncoders and ValueDecoders
+//
+// The ValueEncoder interface is implemented by types that can encode a provided Go type to BSON.
+// The value to encode is provided as a reflect.Value and a bsonrw.ValueWriter is used within the
+// EncodeValue method to actually create the BSON representation. For convenience, ValueEncoderFunc
+// is provided to allow use of a function with the correct signature as a ValueEncoder. An
+// EncodeContext instance is provided to allow implementations to lookup further ValueEncoders and
+// to provide configuration information.
+//
+// The ValueDecoder interface is the inverse of the ValueEncoder. Implementations should ensure that
+// the value they receive is settable. Similar to ValueEncoderFunc, ValueDecoderFunc is provided to
+// allow the use of a function with the correct signature as a ValueDecoder. A DecodeContext
+// instance is provided and serves similar functionality to the EncodeContext.
+//
+// # DefaultValueEncoders and DefaultValueDecoders
+//
+// The DefaultValueEncoders and DefaultValueDecoders types provide a full set of ValueEncoders and
+// ValueDecoders for handling a wide range of Go types, including all of the types within the
+// primitive package. To make registering these codecs easier, a helper method on each type is
+// provided. For the DefaultValueEncoders type the method is called RegisterDefaultEncoders and for
+// the DefaultValueDecoders type the method is called RegisterDefaultDecoders, this method also
+// handles registering type map entries for each BSON type.
+
 package bson
 
 import (

bson/bsonrwtest.go renamed to bson/bsonrw_test.go

@@ -214,11 +214,11 @@ func copyValueFromBytes(dst ValueWriter, t Type, src []byte) error {
 	return copyValue(dst, vr)
 }
 
-// copyValueToBytes copies a value from src and returns it as a Type and a
+// CopyValueToBytes copies a value from src and returns it as a Type and a
 // []byte.
 //
 // Deprecated: Use [go.mongodb.org/mongo-driver/bson.MarshalValue] instead.
-func copyValueToBytes(src ValueReader) (Type, []byte, error) {
+func CopyValueToBytes(src ValueReader) (Type, []byte, error) {
 	return appendValueBytes(nil, src)
 }
 

bson/copier.go

@@ -454,7 +454,7 @@ func TestCopier(t *testing.T) {
 			noerr(t, err)
 			_, _, err = vr.ReadElement()
 			noerr(t, err)
-			btype, got, err := copyValueToBytes(vr)
+			btype, got, err := CopyValueToBytes(vr)
 			noerr(t, err)
 			want := bsoncore.AppendString(nil, "world")
 			if btype != TypeString {
@@ -466,7 +466,7 @@ func TestCopier(t *testing.T) {
 		})
 		t.Run("Non BytesReader", func(t *testing.T) {
 			llvrw := &TestValueReaderWriter{t: t, bsontype: TypeString, readval: "Hello, world!"}
-			btype, got, err := copyValueToBytes(llvrw)
+			btype, got, err := CopyValueToBytes(llvrw)
 			noerr(t, err)
 			want := bsoncore.AppendString(nil, "Hello, world!")
 			if btype != TypeString {

bson/copier_test.go

@@ -18,13 +18,13 @@ import (
 	"strconv"
 	"strings"
 
-	"go.mongodb.org/mongo-driver/bson/util"
+	"go.mongodb.org/mongo-driver/internal/bsonutil/primitive"
 )
 
 // These constants are the maximum and minimum values for the exponent field in a decimal128 value.
 const (
-	MaxDecimal128Exp = util.MaxDecimal128Exp
-	MinDecimal128Exp = util.MinDecimal128Exp
+	MaxDecimal128Exp = 6111
+	MinDecimal128Exp = -6176
 )
 
 // These errors are returned when an invalid value is parsed as a big.Int.
@@ -52,7 +52,7 @@ func (d Decimal128) GetBytes() (uint64, uint64) {
 
 // String returns a string representation of the decimal value.
 func (d Decimal128) String() string {
-	return util.Decimal128String(d.h, d.l)
+	return primitive.Decimal128String(d.h, d.l)
 }
 
 // BigInt returns significand as big.Int and exponent, bi * 10 ^ exp.

bson/decimal.go

@@ -1532,7 +1532,7 @@ func (dvd DefaultValueDecoders) ValueUnmarshalerDecodeValue(_ DecodeContext, vr
 		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
 	}
 
-	t, src, err := copyValueToBytes(vr)
+	t, src, err := CopyValueToBytes(vr)
 	if err != nil {
 		return err
 	}
@@ -1561,7 +1561,7 @@ func (dvd DefaultValueDecoders) UnmarshalerDecodeValue(_ DecodeContext, vr Value
 		val.Set(reflect.New(val.Type().Elem()))
 	}
 
-	_, src, err := copyValueToBytes(vr)
+	_, src, err := CopyValueToBytes(vr)
 	if err != nil {
 		return err
 	}

bson/default_value_decoders.go

@@ -135,8 +135,6 @@
 //
 // Manually marshaling and unmarshaling can be done with the Marshal and Unmarshal family of functions.
 //
-// ---
-//
 // bsoncodec code provides a system for encoding values to BSON representations and decoding
 // values from BSON representations. This package considers both binary BSON and ExtendedJSON as
 // BSON representations. The types in this package enable a flexible system for handling this
@@ -150,81 +148,5 @@
 // 2) A Registry that holds these ValueEncoders and ValueDecoders and provides methods for
 // retrieving them.
 //
-// # ValueEncoders and ValueDecoders
-//
-// The ValueEncoder interface is implemented by types that can encode a provided Go type to BSON.
-// The value to encode is provided as a reflect.Value and a bsonrw.ValueWriter is used within the
-// EncodeValue method to actually create the BSON representation. For convenience, ValueEncoderFunc
-// is provided to allow use of a function with the correct signature as a ValueEncoder. An
-// EncodeContext instance is provided to allow implementations to lookup further ValueEncoders and
-// to provide configuration information.
-//
-// The ValueDecoder interface is the inverse of the ValueEncoder. Implementations should ensure that
-// the value they receive is settable. Similar to ValueEncoderFunc, ValueDecoderFunc is provided to
-// allow the use of a function with the correct signature as a ValueDecoder. A DecodeContext
-// instance is provided and serves similar functionality to the EncodeContext.
-//
-// # Registry
-//
-// A Registry is a store for ValueEncoders, ValueDecoders, and a type map. See the Registry type
-// documentation for examples of registering various custom encoders and decoders. A Registry can
-// have three main types of codecs:
-//
-// 1. Type encoders/decoders - These can be registered using the RegisterTypeEncoder and
-// RegisterTypeDecoder methods. The registered codec will be invoked when encoding/decoding a value
-// whose type matches the registered type exactly.
-// If the registered type is an interface, the codec will be invoked when encoding or decoding
-// values whose type is the interface, but not for values with concrete types that implement the
-// interface.
-//
-// 2. Hook encoders/decoders - These can be registered using the RegisterHookEncoder and
-// RegisterHookDecoder methods. These methods only accept interface types and the registered codecs
-// will be invoked when encoding or decoding values whose types implement the interface. An example
-// of a hook defined by the driver is bson.Marshaler. The driver will call the MarshalBSON method
-// for any value whose type implements bson.Marshaler, regardless of the value's concrete type.
-//
-// 3. Type map entries - This can be used to associate a BSON type with a Go type. These type
-// associations are used when decoding into a bson.D/bson.M or a struct field of type interface{}.
-// For example, by default, BSON int32 and int64 values decode as Go int32 and int64 instances,
-// respectively, when decoding into a bson.D. The following code would change the behavior so these
-// values decode as Go int instances instead:
-//
-//	intType := reflect.TypeOf(int(0))
-//	registry.RegisterTypeMapEntry(bson.TypeInt32, intType).RegisterTypeMapEntry(bson.TypeInt64, intType)
-//
-// 4. Kind encoder/decoders - These can be registered using the RegisterDefaultEncoder and
-// RegisterDefaultDecoder methods. The registered codec will be invoked when encoding or decoding
-// values whose reflect.Kind matches the registered reflect.Kind as long as the value's type doesn't
-// match a registered type or hook encoder/decoder first. These methods should be used to change the
-// behavior for all values for a specific kind.
-//
-// # Registry Lookup Procedure
-//
-// When looking up an encoder in a Registry, the precedence rules are as follows:
-//
-// 1. A type encoder registered for the exact type of the value.
-//
-// 2. A hook encoder registered for an interface that is implemented by the value or by a pointer to
-// the value. If the value matches multiple hooks (e.g. the type implements bsoncodec.Marshaler and
-// bsoncodec.ValueMarshaler), the first one registered will be selected. Note that registries
-// constructed using bson.NewRegistry have driver-defined hooks registered for the
-// bsoncodec.Marshaler, bsoncodec.ValueMarshaler, and bsoncodec.Proxy interfaces, so those will take
-// precedence over any new hooks.
-//
-// 3. A kind encoder registered for the value's kind.
-//
-// If all of these lookups fail to find an encoder, an error of type ErrNoEncoder is returned. The
-// same precedence rules apply for decoders, with the exception that an error of type ErrNoDecoder
-// will be returned if no decoder is found.
-//
-// # DefaultValueEncoders and DefaultValueDecoders
-//
-// The DefaultValueEncoders and DefaultValueDecoders types provide a full set of ValueEncoders and
-// ValueDecoders for handling a wide range of Go types, including all of the types within the
-// primitive package. To make registering these codecs easier, a helper method on each type is
-// provided. For the DefaultValueEncoders type the method is called RegisterDefaultEncoders and for
-// the DefaultValueDecoders type the method is called RegisterDefaultDecoders, this method also
-// handles registering type map entries for each BSON type.
-//
 // [Work with BSON]: https://www.mongodb.com/docs/drivers/go/current/fundamentals/bson/
 package bson

bson/doc.go

@@ -137,7 +137,7 @@ func ExampleEncoder_multipleBSONDocuments() {
 	// Read each marshaled BSON document from the buffer and print them as
 	// Extended JSON by converting them to bson.Raw.
 	for {
-		doc, err := bson.ReadRawDocument(buf)
+		doc, err := bson.ReadDocument(buf)
 		if errors.Is(err, io.EOF) {
 			return
 		}