fix: error handling and vendor
All checks were successful
continuous-integration/drone/push Build is passing
All checks were successful
continuous-integration/drone/push Build is passing
This commit is contained in:
434
vendor/go.mongodb.org/mongo-driver/bson/primitive/decimal.go
generated
vendored
Normal file
434
vendor/go.mongodb.org/mongo-driver/bson/primitive/decimal.go
generated
vendored
Normal file
@ -0,0 +1,434 @@
|
||||
// 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)
|
||||
}
|
||||
206
vendor/go.mongodb.org/mongo-driver/bson/primitive/objectid.go
generated
vendored
Normal file
206
vendor/go.mongodb.org/mongo-driver/bson/primitive/objectid.go
generated
vendored
Normal file
@ -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
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
231
vendor/go.mongodb.org/mongo-driver/bson/primitive/primitive.go
generated
vendored
Normal file
231
vendor/go.mongodb.org/mongo-driver/bson/primitive/primitive.go
generated
vendored
Normal file
@ -0,0 +1,231 @@
|
||||
// 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{}
|
||||
Reference in New Issue
Block a user