diff options
Diffstat (limited to 'vendor/go.mongodb.org/mongo-driver/bson/primitive')
3 files changed, 846 insertions, 0 deletions
diff --git a/vendor/go.mongodb.org/mongo-driver/bson/primitive/decimal.go b/vendor/go.mongodb.org/mongo-driver/bson/primitive/decimal.go new file mode 100644 index 000000000..ba7c9112e --- /dev/null +++ b/vendor/go.mongodb.org/mongo-driver/bson/primitive/decimal.go @@ -0,0 +1,423 @@ +// Copyright (C) MongoDB, Inc. 2017-present. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may +// 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 +// +// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer +// See THIRD-PARTY-NOTICES for original license terms. + +package primitive + +import ( + "encoding/json" + "errors" + "fmt" + "math/big" + "regexp" + "strconv" + "strings" +) + +// These constants are the maximum and minimum values for the exponent field in a decimal128 value. +const ( + MaxDecimal128Exp = 6111 + MinDecimal128Exp = -6176 +) + +// These errors are returned when an invalid value is parsed as a big.Int. +var ( + ErrParseNaN = errors.New("cannot parse NaN as a *big.Int") + ErrParseInf = errors.New("cannot parse Infinity as a *big.Int") + ErrParseNegInf = errors.New("cannot parse -Infinity as a *big.Int") +) + +// Decimal128 holds decimal128 BSON values. +type Decimal128 struct { + h, l uint64 +} + +// NewDecimal128 creates a Decimal128 using the provide high and low uint64s. +func NewDecimal128(h, l uint64) Decimal128 { + return Decimal128{h: h, l: l} +} + +// GetBytes returns the underlying bytes of the BSON decimal value as two uint64 values. The first +// contains the most first 8 bytes of the value and the second contains the latter. +func (d Decimal128) GetBytes() (uint64, uint64) { + return d.h, d.l +} + +// String returns a string representation of the decimal value. +func (d Decimal128) String() string { + var posSign int // positive sign + var exp int // exponent + var high, low uint64 // significand high/low + + if d.h>>63&1 == 0 { + posSign = 1 + } + + switch d.h >> 58 & (1<<5 - 1) { + case 0x1F: + return "NaN" + case 0x1E: + return "-Infinity"[posSign:] + } + + low = d.l + if d.h>>61&3 == 3 { + // Bits: 1*sign 2*ignored 14*exponent 111*significand. + // Implicit 0b100 prefix in significand. + exp = int(d.h >> 47 & (1<<14 - 1)) + //high = 4<<47 | d.h&(1<<47-1) + // Spec says all of these values are out of range. + high, low = 0, 0 + } else { + // Bits: 1*sign 14*exponent 113*significand + exp = int(d.h >> 49 & (1<<14 - 1)) + high = d.h & (1<<49 - 1) + } + exp += MinDecimal128Exp + + // Would be handled by the logic below, but that's trivial and common. + if high == 0 && low == 0 && exp == 0 { + return "-0"[posSign:] + } + + var repr [48]byte // Loop 5 times over 9 digits plus dot, negative sign, and leading zero. + var last = len(repr) + var i = len(repr) + var dot = len(repr) + exp + var rem uint32 +Loop: + for d9 := 0; d9 < 5; d9++ { + high, low, rem = divmod(high, low, 1e9) + for d1 := 0; d1 < 9; d1++ { + // Handle "-0.0", "0.00123400", "-1.00E-6", "1.050E+3", etc. + if i < len(repr) && (dot == i || low == 0 && high == 0 && rem > 0 && rem < 10 && (dot < i-6 || exp > 0)) { + exp += len(repr) - i + i-- + repr[i] = '.' + last = i - 1 + dot = len(repr) // Unmark. + } + c := '0' + byte(rem%10) + rem /= 10 + i-- + repr[i] = c + // Handle "0E+3", "1E+3", etc. + if low == 0 && high == 0 && rem == 0 && i == len(repr)-1 && (dot < i-5 || exp > 0) { + last = i + break Loop + } + if c != '0' { + last = i + } + // Break early. Works without it, but why. + if dot > i && low == 0 && high == 0 && rem == 0 { + break Loop + } + } + } + repr[last-1] = '-' + last-- + + if exp > 0 { + return string(repr[last+posSign:]) + "E+" + strconv.Itoa(exp) + } + if exp < 0 { + return string(repr[last+posSign:]) + "E" + strconv.Itoa(exp) + } + return string(repr[last+posSign:]) +} + +// BigInt returns significand as big.Int and exponent, bi * 10 ^ exp. +func (d Decimal128) BigInt() (*big.Int, int, error) { + high, low := d.GetBytes() + posSign := high>>63&1 == 0 // positive sign + + switch high >> 58 & (1<<5 - 1) { + case 0x1F: + return nil, 0, ErrParseNaN + case 0x1E: + if posSign { + return nil, 0, ErrParseInf + } + return nil, 0, ErrParseNegInf + } + + var exp int + if high>>61&3 == 3 { + // Bits: 1*sign 2*ignored 14*exponent 111*significand. + // Implicit 0b100 prefix in significand. + exp = int(high >> 47 & (1<<14 - 1)) + //high = 4<<47 | d.h&(1<<47-1) + // Spec says all of these values are out of range. + high, low = 0, 0 + } else { + // Bits: 1*sign 14*exponent 113*significand + exp = int(high >> 49 & (1<<14 - 1)) + high = high & (1<<49 - 1) + } + exp += MinDecimal128Exp + + // Would be handled by the logic below, but that's trivial and common. + if high == 0 && low == 0 && exp == 0 { + if posSign { + return new(big.Int), 0, nil + } + return new(big.Int), 0, nil + } + + bi := big.NewInt(0) + const host32bit = ^uint(0)>>32 == 0 + if host32bit { + bi.SetBits([]big.Word{big.Word(low), big.Word(low >> 32), big.Word(high), big.Word(high >> 32)}) + } else { + bi.SetBits([]big.Word{big.Word(low), big.Word(high)}) + } + + if !posSign { + return bi.Neg(bi), exp, nil + } + return bi, exp, nil +} + +// IsNaN returns whether d is NaN. +func (d Decimal128) IsNaN() bool { + return d.h>>58&(1<<5-1) == 0x1F +} + +// IsInf returns: +// +// +1 d == Infinity +// 0 other case +// -1 d == -Infinity +func (d Decimal128) IsInf() int { + if d.h>>58&(1<<5-1) != 0x1E { + return 0 + } + + if d.h>>63&1 == 0 { + return 1 + } + return -1 +} + +// IsZero returns true if d is the empty Decimal128. +func (d Decimal128) IsZero() bool { + return d.h == 0 && d.l == 0 +} + +// MarshalJSON returns Decimal128 as a string. +func (d Decimal128) MarshalJSON() ([]byte, error) { + return json.Marshal(d.String()) +} + +// UnmarshalJSON creates a primitive.Decimal128 from a JSON string, an extended JSON $numberDecimal value, or the string +// "null". If b is a JSON string or extended JSON value, d will have the value of that string, and if b is "null", d will +// be unchanged. +func (d *Decimal128) UnmarshalJSON(b []byte) error { + // Ignore "null" to keep parity with the standard library. Decoding a JSON null into a non-pointer Decimal128 field + // will leave the field unchanged. For pointer values, encoding/json will set the pointer to nil and will not + // enter the UnmarshalJSON hook. + if string(b) == "null" { + return nil + } + + var res interface{} + err := json.Unmarshal(b, &res) + if err != nil { + return err + } + str, ok := res.(string) + + // Extended JSON + if !ok { + m, ok := res.(map[string]interface{}) + if !ok { + return errors.New("not an extended JSON Decimal128: expected document") + } + d128, ok := m["$numberDecimal"] + if !ok { + return errors.New("not an extended JSON Decimal128: expected key $numberDecimal") + } + str, ok = d128.(string) + if !ok { + return errors.New("not an extended JSON Decimal128: expected decimal to be string") + } + } + + *d, err = ParseDecimal128(str) + return err +} + +func divmod(h, l uint64, div uint32) (qh, ql uint64, rem uint32) { + div64 := uint64(div) + a := h >> 32 + aq := a / div64 + ar := a % div64 + b := ar<<32 + h&(1<<32-1) + bq := b / div64 + br := b % div64 + c := br<<32 + l>>32 + cq := c / div64 + cr := c % div64 + d := cr<<32 + l&(1<<32-1) + dq := d / div64 + dr := d % div64 + return (aq<<32 | bq), (cq<<32 | dq), uint32(dr) +} + +var dNaN = Decimal128{0x1F << 58, 0} +var dPosInf = Decimal128{0x1E << 58, 0} +var dNegInf = Decimal128{0x3E << 58, 0} + +func dErr(s string) (Decimal128, error) { + return dNaN, fmt.Errorf("cannot parse %q as a decimal128", s) +} + +// match scientific notation number, example -10.15e-18 +var normalNumber = regexp.MustCompile(`^(?P<int>[-+]?\d*)?(?:\.(?P<dec>\d*))?(?:[Ee](?P<exp>[-+]?\d+))?$`) + +// ParseDecimal128 takes the given string and attempts to parse it into a valid +// Decimal128 value. +func ParseDecimal128(s string) (Decimal128, error) { + if s == "" { + return dErr(s) + } + + matches := normalNumber.FindStringSubmatch(s) + if len(matches) == 0 { + orig := s + neg := s[0] == '-' + if neg || s[0] == '+' { + s = s[1:] + } + + if s == "NaN" || s == "nan" || strings.EqualFold(s, "nan") { + return dNaN, nil + } + if s == "Inf" || s == "inf" || strings.EqualFold(s, "inf") || strings.EqualFold(s, "infinity") { + if neg { + return dNegInf, nil + } + return dPosInf, nil + } + return dErr(orig) + } + + intPart := matches[1] + decPart := matches[2] + expPart := matches[3] + + var err error + exp := 0 + if expPart != "" { + exp, err = strconv.Atoi(expPart) + if err != nil { + return dErr(s) + } + } + if decPart != "" { + exp -= len(decPart) + } + + if len(strings.Trim(intPart+decPart, "-0")) > 35 { + return dErr(s) + } + + bi, ok := new(big.Int).SetString(intPart+decPart, 10) + if !ok { + return dErr(s) + } + + d, ok := ParseDecimal128FromBigInt(bi, exp) + if !ok { + return dErr(s) + } + + if bi.Sign() == 0 && s[0] == '-' { + d.h |= 1 << 63 + } + + return d, nil +} + +var ( + ten = big.NewInt(10) + zero = new(big.Int) + + maxS, _ = new(big.Int).SetString("9999999999999999999999999999999999", 10) +) + +// ParseDecimal128FromBigInt attempts to parse the given significand and exponent into a valid Decimal128 value. +func ParseDecimal128FromBigInt(bi *big.Int, exp int) (Decimal128, bool) { + //copy + bi = new(big.Int).Set(bi) + + q := new(big.Int) + r := new(big.Int) + + for bigIntCmpAbs(bi, maxS) == 1 { + bi, _ = q.QuoRem(bi, ten, r) + if r.Cmp(zero) != 0 { + return Decimal128{}, false + } + exp++ + if exp > MaxDecimal128Exp { + return Decimal128{}, false + } + } + + for exp < MinDecimal128Exp { + // Subnormal. + bi, _ = q.QuoRem(bi, ten, r) + if r.Cmp(zero) != 0 { + return Decimal128{}, false + } + exp++ + } + for exp > MaxDecimal128Exp { + // Clamped. + bi.Mul(bi, ten) + if bigIntCmpAbs(bi, maxS) == 1 { + return Decimal128{}, false + } + exp-- + } + + b := bi.Bytes() + var h, l uint64 + for i := 0; i < len(b); i++ { + if i < len(b)-8 { + h = h<<8 | uint64(b[i]) + continue + } + l = l<<8 | uint64(b[i]) + } + + h |= uint64(exp-MinDecimal128Exp) & uint64(1<<14-1) << 49 + if bi.Sign() == -1 { + h |= 1 << 63 + } + + return Decimal128{h: h, l: l}, true +} + +// bigIntCmpAbs computes big.Int.Cmp(absoluteValue(x), absoluteValue(y)). +func bigIntCmpAbs(x, y *big.Int) int { + xAbs := bigIntAbsValue(x) + yAbs := bigIntAbsValue(y) + return xAbs.Cmp(yAbs) +} + +// bigIntAbsValue returns a big.Int containing the absolute value of b. +// If b is already a non-negative number, it is returned without any changes or copies. +func bigIntAbsValue(b *big.Int) *big.Int { + if b.Sign() >= 0 { + return b // already positive + } + return new(big.Int).Abs(b) +} diff --git a/vendor/go.mongodb.org/mongo-driver/bson/primitive/objectid.go b/vendor/go.mongodb.org/mongo-driver/bson/primitive/objectid.go new file mode 100644 index 000000000..ded367316 --- /dev/null +++ b/vendor/go.mongodb.org/mongo-driver/bson/primitive/objectid.go @@ -0,0 +1,206 @@ +// Copyright (C) MongoDB, Inc. 2017-present. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may +// 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 +// +// Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer +// See THIRD-PARTY-NOTICES for original license terms. + +package primitive + +import ( + "crypto/rand" + "encoding" + "encoding/binary" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "sync/atomic" + "time" +) + +// ErrInvalidHex indicates that a hex string cannot be converted to an ObjectID. +var ErrInvalidHex = errors.New("the provided hex string is not a valid ObjectID") + +// ObjectID is the BSON ObjectID type. +type ObjectID [12]byte + +// NilObjectID is the zero value for ObjectID. +var NilObjectID ObjectID + +var objectIDCounter = readRandomUint32() +var processUnique = processUniqueBytes() + +var _ encoding.TextMarshaler = ObjectID{} +var _ encoding.TextUnmarshaler = &ObjectID{} + +// NewObjectID generates a new ObjectID. +func NewObjectID() ObjectID { + return NewObjectIDFromTimestamp(time.Now()) +} + +// NewObjectIDFromTimestamp generates a new ObjectID based on the given time. +func NewObjectIDFromTimestamp(timestamp time.Time) ObjectID { + var b [12]byte + + binary.BigEndian.PutUint32(b[0:4], uint32(timestamp.Unix())) + copy(b[4:9], processUnique[:]) + putUint24(b[9:12], atomic.AddUint32(&objectIDCounter, 1)) + + return b +} + +// Timestamp extracts the time part of the ObjectId. +func (id ObjectID) Timestamp() time.Time { + unixSecs := binary.BigEndian.Uint32(id[0:4]) + return time.Unix(int64(unixSecs), 0).UTC() +} + +// Hex returns the hex encoding of the ObjectID as a string. +func (id ObjectID) Hex() string { + var buf [24]byte + hex.Encode(buf[:], id[:]) + return string(buf[:]) +} + +func (id ObjectID) String() string { + return fmt.Sprintf("ObjectID(%q)", id.Hex()) +} + +// IsZero returns true if id is the empty ObjectID. +func (id ObjectID) IsZero() bool { + return id == NilObjectID +} + +// ObjectIDFromHex creates a new ObjectID from a hex string. It returns an error if the hex string is not a +// valid ObjectID. +func ObjectIDFromHex(s string) (ObjectID, error) { + if len(s) != 24 { + return NilObjectID, ErrInvalidHex + } + + b, err := hex.DecodeString(s) + if err != nil { + return NilObjectID, err + } + + var oid [12]byte + copy(oid[:], b) + + return oid, nil +} + +// IsValidObjectID returns true if the provided hex string represents a valid ObjectID and false if not. +func IsValidObjectID(s string) bool { + _, err := ObjectIDFromHex(s) + return err == nil +} + +// MarshalText returns the ObjectID as UTF-8-encoded text. Implementing this allows us to use ObjectID +// as a map key when marshalling JSON. See https://pkg.go.dev/encoding#TextMarshaler +func (id ObjectID) MarshalText() ([]byte, error) { + return []byte(id.Hex()), nil +} + +// UnmarshalText populates the byte slice with the ObjectID. Implementing this allows us to use ObjectID +// as a map key when unmarshalling JSON. See https://pkg.go.dev/encoding#TextUnmarshaler +func (id *ObjectID) UnmarshalText(b []byte) error { + oid, err := ObjectIDFromHex(string(b)) + if err != nil { + return err + } + *id = oid + return nil +} + +// MarshalJSON returns the ObjectID as a string +func (id ObjectID) MarshalJSON() ([]byte, error) { + return json.Marshal(id.Hex()) +} + +// UnmarshalJSON populates the byte slice with the ObjectID. If the byte slice is 24 bytes long, it +// will be populated with the hex representation of the ObjectID. If the byte slice is twelve bytes +// long, it will be populated with the BSON representation of the ObjectID. This method also accepts empty strings and +// decodes them as NilObjectID. For any other inputs, an error will be returned. +func (id *ObjectID) UnmarshalJSON(b []byte) error { + // Ignore "null" to keep parity with the standard library. Decoding a JSON null into a non-pointer ObjectID field + // will leave the field unchanged. For pointer values, encoding/json will set the pointer to nil and will not + // enter the UnmarshalJSON hook. + if string(b) == "null" { + return nil + } + + var err error + switch len(b) { + case 12: + copy(id[:], b) + default: + // Extended JSON + var res interface{} + err := json.Unmarshal(b, &res) + if err != nil { + return err + } + str, ok := res.(string) + if !ok { + m, ok := res.(map[string]interface{}) + if !ok { + return errors.New("not an extended JSON ObjectID") + } + oid, ok := m["$oid"] + if !ok { + return errors.New("not an extended JSON ObjectID") + } + str, ok = oid.(string) + if !ok { + return errors.New("not an extended JSON ObjectID") + } + } + + // An empty string is not a valid ObjectID, but we treat it as a special value that decodes as NilObjectID. + if len(str) == 0 { + copy(id[:], NilObjectID[:]) + return nil + } + + if len(str) != 24 { + return fmt.Errorf("cannot unmarshal into an ObjectID, the length must be 24 but it is %d", len(str)) + } + + _, err = hex.Decode(id[:], []byte(str)) + if err != nil { + return err + } + } + + return err +} + +func processUniqueBytes() [5]byte { + var b [5]byte + _, err := io.ReadFull(rand.Reader, b[:]) + if err != nil { + panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %v", err)) + } + + return b +} + +func readRandomUint32() uint32 { + var b [4]byte + _, err := io.ReadFull(rand.Reader, b[:]) + if err != nil { + panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %v", err)) + } + + return (uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24) +} + +func putUint24(b []byte, v uint32) { + b[0] = byte(v >> 16) + b[1] = byte(v >> 8) + b[2] = byte(v) +} diff --git a/vendor/go.mongodb.org/mongo-driver/bson/primitive/primitive.go b/vendor/go.mongodb.org/mongo-driver/bson/primitive/primitive.go new file mode 100644 index 000000000..c72ccc1c4 --- /dev/null +++ b/vendor/go.mongodb.org/mongo-driver/bson/primitive/primitive.go @@ -0,0 +1,217 @@ +// Copyright (C) MongoDB, Inc. 2017-present. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may +// 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 + +// Package primitive contains types similar to Go primitives for BSON types that do not have direct +// Go primitive representations. +package primitive // import "go.mongodb.org/mongo-driver/bson/primitive" + +import ( + "bytes" + "encoding/json" + "fmt" + "time" +) + +// Binary represents a BSON binary value. +type Binary struct { + Subtype byte + Data []byte +} + +// Equal compares bp to bp2 and returns true if they are equal. +func (bp Binary) Equal(bp2 Binary) bool { + if bp.Subtype != bp2.Subtype { + return false + } + return bytes.Equal(bp.Data, bp2.Data) +} + +// IsZero returns if bp is the empty Binary. +func (bp Binary) IsZero() bool { + return bp.Subtype == 0 && len(bp.Data) == 0 +} + +// Undefined represents the BSON undefined value type. +type Undefined struct{} + +// DateTime represents the BSON datetime value. +type DateTime int64 + +var _ json.Marshaler = DateTime(0) +var _ json.Unmarshaler = (*DateTime)(nil) + +// MarshalJSON marshal to time type. +func (d DateTime) MarshalJSON() ([]byte, error) { + return json.Marshal(d.Time()) +} + +// UnmarshalJSON creates a primitive.DateTime from a JSON string. +func (d *DateTime) UnmarshalJSON(data []byte) error { + // Ignore "null" to keep parity with the time.Time type and the standard library. Decoding "null" into a non-pointer + // DateTime field will leave the field unchanged. For pointer values, the encoding/json will set the pointer to nil + // and will not defer to the UnmarshalJSON hook. + if string(data) == "null" { + return nil + } + + var tempTime time.Time + if err := json.Unmarshal(data, &tempTime); err != nil { + return err + } + + *d = NewDateTimeFromTime(tempTime) + return nil +} + +// Time returns the date as a time type. +func (d DateTime) Time() time.Time { + return time.Unix(int64(d)/1000, int64(d)%1000*1000000) +} + +// NewDateTimeFromTime creates a new DateTime from a Time. +func NewDateTimeFromTime(t time.Time) DateTime { + return DateTime(t.Unix()*1e3 + int64(t.Nanosecond())/1e6) +} + +// Null represents the BSON null value. +type Null struct{} + +// Regex represents a BSON regex value. +type Regex struct { + Pattern string + Options string +} + +func (rp Regex) String() string { + return fmt.Sprintf(`{"pattern": "%s", "options": "%s"}`, rp.Pattern, rp.Options) +} + +// Equal compares rp to rp2 and returns true if they are equal. +func (rp Regex) Equal(rp2 Regex) bool { + return rp.Pattern == rp2.Pattern && rp.Options == rp2.Options +} + +// IsZero returns if rp is the empty Regex. +func (rp Regex) IsZero() bool { + return rp.Pattern == "" && rp.Options == "" +} + +// DBPointer represents a BSON dbpointer value. +type DBPointer struct { + DB string + Pointer ObjectID +} + +func (d DBPointer) String() string { + return fmt.Sprintf(`{"db": "%s", "pointer": "%s"}`, d.DB, d.Pointer) +} + +// Equal compares d to d2 and returns true if they are equal. +func (d DBPointer) Equal(d2 DBPointer) bool { + return d == d2 +} + +// IsZero returns if d is the empty DBPointer. +func (d DBPointer) IsZero() bool { + return d.DB == "" && d.Pointer.IsZero() +} + +// JavaScript represents a BSON JavaScript code value. +type JavaScript string + +// Symbol represents a BSON symbol value. +type Symbol string + +// CodeWithScope represents a BSON JavaScript code with scope value. +type CodeWithScope struct { + Code JavaScript + Scope interface{} +} + +func (cws CodeWithScope) String() string { + return fmt.Sprintf(`{"code": "%s", "scope": %v}`, cws.Code, cws.Scope) +} + +// Timestamp represents a BSON timestamp value. +type Timestamp struct { + T uint32 + I uint32 +} + +// Equal compares tp to tp2 and returns true if they are equal. +func (tp Timestamp) Equal(tp2 Timestamp) bool { + return tp.T == tp2.T && tp.I == tp2.I +} + +// IsZero returns if tp is the zero Timestamp. +func (tp Timestamp) IsZero() bool { + return tp.T == 0 && tp.I == 0 +} + +// CompareTimestamp returns an integer comparing two Timestamps, where T is compared first, followed by I. +// Returns 0 if tp = tp2, 1 if tp > tp2, -1 if tp < tp2. +func CompareTimestamp(tp, tp2 Timestamp) int { + if tp.Equal(tp2) { + return 0 + } + + if tp.T > tp2.T { + return 1 + } + if tp.T < tp2.T { + return -1 + } + // Compare I values because T values are equal + if tp.I > tp2.I { + return 1 + } + return -1 +} + +// MinKey represents the BSON minkey value. +type MinKey struct{} + +// MaxKey represents the BSON maxkey value. +type MaxKey struct{} + +// D is an ordered representation of a BSON document. This type should be used when the order of the elements matters, +// such as MongoDB command documents. If the order of the elements does not matter, an M should be used instead. +// +// Example usage: +// +// bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}} +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{} +} + +// M is an unordered representation of a BSON document. This type should be used when the order of the elements does not +// matter. This type is handled as a regular map[string]interface{} when encoding and decoding. Elements will be +// serialized in an undefined, random order. If the order of the elements matters, a D should be used instead. +// +// Example usage: +// +// bson.M{"foo": "bar", "hello": "world", "pi": 3.14159} +type M map[string]interface{} + +// An A is an ordered representation of a BSON array. +// +// Example usage: +// +// bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}} +type A []interface{} |