diff options
Diffstat (limited to 'vendor/go.mongodb.org/mongo-driver/bson/primitive')
3 files changed, 0 insertions, 871 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 deleted file mode 100644 index 08c39514b..000000000 --- a/vendor/go.mongodb.org/mongo-driver/bson/primitive/decimal.go +++ /dev/null @@ -1,434 +0,0 @@ -// 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 { - 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) - } - - // Parse the significand (i.e. the non-exponent part) as a big.Int. - 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) - - // If the significand is zero, the logical value will always be zero, independent of the - // exponent. However, the loops for handling out-of-range exponent values below may be extremely - // slow for zero values because the significand never changes. Limit the exponent value to the - // supported range here to prevent entering the loops below. - if bi.Cmp(zero) == 0 { - if exp > MaxDecimal128Exp { - exp = MaxDecimal128Exp - } - if exp < MinDecimal128Exp { - exp = MinDecimal128Exp - } - } - - 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 deleted file mode 100644 index c130e3ff1..000000000 --- a/vendor/go.mongodb.org/mongo-driver/bson/primitive/objectid.go +++ /dev/null @@ -1,206 +0,0 @@ -// 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 - } - - var oid [12]byte - _, err := hex.Decode(oid[:], []byte(s)) - if err != nil { - return NilObjectID, err - } - - return oid, nil -} - -// IsValidObjectID returns true if the provided hex string represents a valid ObjectID and false if not. -// -// Deprecated: Use ObjectIDFromHex and check the error instead. -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: %w", 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: %w", 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 deleted file mode 100644 index 65f4fbb94..000000000 --- a/vendor/go.mongodb.org/mongo-driver/bson/primitive/primitive.go +++ /dev/null @@ -1,231 +0,0 @@ -// 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().UTC()) -} - -// 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 -} - -// After reports whether the time instant tp is after tp2. -func (tp Timestamp) After(tp2 Timestamp) bool { - return tp.T > tp2.T || (tp.T == tp2.T && tp.I > tp2.I) -} - -// Before reports whether the time instant tp is before tp2. -func (tp Timestamp) Before(tp2 Timestamp) bool { - return tp.T < tp2.T || (tp.T == tp2.T && tp.I < tp2.I) -} - -// 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 -} - -// Compare compares the time instant tp with tp2. If tp is before tp2, it returns -1; if tp is after -// tp2, it returns +1; if they're the same, it returns 0. -func (tp Timestamp) Compare(tp2 Timestamp) int { - switch { - case tp.Equal(tp2): - return 0 - case tp.Before(tp2): - return -1 - default: - return +1 - } -} - -// CompareTimestamp compares the time instant tp with tp2. If tp is before tp2, it returns -1; if tp is after -// tp2, it returns +1; if they're the same, it returns 0. -// -// Deprecated: Use Timestamp.Compare instead. -func CompareTimestamp(tp, tp2 Timestamp) int { - return tp.Compare(tp2) -} - -// 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. -// -// Deprecated: Converting directly from a D to an M will not be supported in Go Driver 2.0. Instead, -// users should marshal the D to BSON using bson.Marshal and unmarshal it to M using bson.Unmarshal. -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{} |