seba-365 - implemented dep
Change-Id: Ia6226d50e7615935a0c8876809a687427ff88c22
diff --git a/vendor/github.com/mongodb/mongo-go-driver/x/bsonx/value.go b/vendor/github.com/mongodb/mongo-go-driver/x/bsonx/value.go
new file mode 100644
index 0000000..033d9d8
--- /dev/null
+++ b/vendor/github.com/mongodb/mongo-go-driver/x/bsonx/value.go
@@ -0,0 +1,899 @@
+// 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 bsonx
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "math"
+ "time"
+
+ "github.com/mongodb/mongo-go-driver/bson/bsontype"
+ "github.com/mongodb/mongo-go-driver/bson/primitive"
+ "github.com/mongodb/mongo-go-driver/x/bsonx/bsoncore"
+)
+
+// Val represents a BSON value.
+type Val struct {
+ // NOTE: The bootstrap is a small amount of space that'll be on the stack. At 15 bytes this
+ // doesn't make this type any larger, since there are 7 bytes of padding and we want an int64 to
+ // store small values (e.g. boolean, double, int64, etc...). The primitive property is where all
+ // of the larger values go. They will use either Go primitives or the primitive.* types.
+ t bsontype.Type
+ bootstrap [15]byte
+ primitive interface{}
+}
+
+func (v Val) reset() Val {
+ v.primitive = nil // clear out any pointers so we don't accidentally stop them from being garbage collected.
+ v.t = bsontype.Type(0)
+ v.bootstrap[0] = 0x00
+ v.bootstrap[1] = 0x00
+ v.bootstrap[2] = 0x00
+ v.bootstrap[3] = 0x00
+ v.bootstrap[4] = 0x00
+ v.bootstrap[5] = 0x00
+ v.bootstrap[6] = 0x00
+ v.bootstrap[7] = 0x00
+ v.bootstrap[8] = 0x00
+ v.bootstrap[9] = 0x00
+ v.bootstrap[10] = 0x00
+ v.bootstrap[11] = 0x00
+ v.bootstrap[12] = 0x00
+ v.bootstrap[13] = 0x00
+ v.bootstrap[14] = 0x00
+ return v
+}
+
+func (v Val) string() string {
+ if v.primitive != nil {
+ return v.primitive.(string)
+ }
+ // The string will either end with a null byte or it fills the entire bootstrap space.
+ length := uint8(v.bootstrap[0])
+ return string(v.bootstrap[1 : length+1])
+}
+
+func (v Val) writestring(str string) Val {
+ switch {
+ case len(str) < 15:
+ v.bootstrap[0] = uint8(len(str))
+ copy(v.bootstrap[1:], str)
+ default:
+ v.primitive = str
+ }
+ return v
+}
+
+func (v Val) i64() int64 {
+ return int64(v.bootstrap[0]) | int64(v.bootstrap[1])<<8 | int64(v.bootstrap[2])<<16 |
+ int64(v.bootstrap[3])<<24 | int64(v.bootstrap[4])<<32 | int64(v.bootstrap[5])<<40 |
+ int64(v.bootstrap[6])<<48 | int64(v.bootstrap[7])<<56
+}
+
+func (v Val) writei64(i64 int64) Val {
+ v.bootstrap[0] = byte(i64)
+ v.bootstrap[1] = byte(i64 >> 8)
+ v.bootstrap[2] = byte(i64 >> 16)
+ v.bootstrap[3] = byte(i64 >> 24)
+ v.bootstrap[4] = byte(i64 >> 32)
+ v.bootstrap[5] = byte(i64 >> 40)
+ v.bootstrap[6] = byte(i64 >> 48)
+ v.bootstrap[7] = byte(i64 >> 56)
+ return v
+}
+
+// IsZero returns true if this value is zero or a BSON null.
+func (v Val) IsZero() bool { return v.t == bsontype.Type(0) || v.t == bsontype.Null }
+
+func (v Val) String() string {
+ // TODO(GODRIVER-612): When bsoncore has appenders for extended JSON use that here.
+ return fmt.Sprintf("%v", v.Interface())
+}
+
+// Interface returns the Go value of this Value as an empty interface.
+//
+// This method will return nil if it is empty, otherwise it will return a Go primitive or a
+// primitive.* instance.
+func (v Val) Interface() interface{} {
+ switch v.Type() {
+ case bsontype.Double:
+ return v.Double()
+ case bsontype.String:
+ return v.StringValue()
+ case bsontype.EmbeddedDocument:
+ switch v.primitive.(type) {
+ case Doc:
+ return v.primitive.(Doc)
+ case MDoc:
+ return v.primitive.(MDoc)
+ default:
+ return primitive.Null{}
+ }
+ case bsontype.Array:
+ return v.Array()
+ case bsontype.Binary:
+ return v.primitive.(primitive.Binary)
+ case bsontype.Undefined:
+ return primitive.Undefined{}
+ case bsontype.ObjectID:
+ return v.ObjectID()
+ case bsontype.Boolean:
+ return v.Boolean()
+ case bsontype.DateTime:
+ return v.DateTime()
+ case bsontype.Null:
+ return primitive.Null{}
+ case bsontype.Regex:
+ return v.primitive.(primitive.Regex)
+ case bsontype.DBPointer:
+ return v.primitive.(primitive.DBPointer)
+ case bsontype.JavaScript:
+ return v.JavaScript()
+ case bsontype.Symbol:
+ return v.Symbol()
+ case bsontype.CodeWithScope:
+ return v.primitive.(primitive.CodeWithScope)
+ case bsontype.Int32:
+ return v.Int32()
+ case bsontype.Timestamp:
+ t, i := v.Timestamp()
+ return primitive.Timestamp{T: t, I: i}
+ case bsontype.Int64:
+ return v.Int64()
+ case bsontype.Decimal128:
+ return v.Decimal128()
+ case bsontype.MinKey:
+ return primitive.MinKey{}
+ case bsontype.MaxKey:
+ return primitive.MaxKey{}
+ default:
+ return primitive.Null{}
+ }
+}
+
+// MarshalBSONValue implements the bsoncodec.ValueMarshaler interface.
+func (v Val) MarshalBSONValue() (bsontype.Type, []byte, error) {
+ return v.MarshalAppendBSONValue(nil)
+}
+
+// MarshalAppendBSONValue is similar to MarshalBSONValue, but allows the caller to specify a slice
+// to add the bytes to.
+func (v Val) MarshalAppendBSONValue(dst []byte) (bsontype.Type, []byte, error) {
+ t := v.Type()
+ switch v.Type() {
+ case bsontype.Double:
+ dst = bsoncore.AppendDouble(dst, v.Double())
+ case bsontype.String:
+ dst = bsoncore.AppendString(dst, v.String())
+ case bsontype.EmbeddedDocument:
+ switch v.primitive.(type) {
+ case Doc:
+ t, dst, _ = v.primitive.(Doc).MarshalBSONValue() // Doc.MarshalBSONValue never returns an error.
+ case MDoc:
+ t, dst, _ = v.primitive.(MDoc).MarshalBSONValue() // MDoc.MarshalBSONValue never returns an error.
+ }
+ case bsontype.Array:
+ t, dst, _ = v.Array().MarshalBSONValue() // Arr.MarshalBSON never returns an error.
+ case bsontype.Binary:
+ subtype, bindata := v.Binary()
+ dst = bsoncore.AppendBinary(dst, subtype, bindata)
+ case bsontype.Undefined:
+ case bsontype.ObjectID:
+ dst = bsoncore.AppendObjectID(dst, v.ObjectID())
+ case bsontype.Boolean:
+ dst = bsoncore.AppendBoolean(dst, v.Boolean())
+ case bsontype.DateTime:
+ dst = bsoncore.AppendDateTime(dst, int64(v.DateTime()))
+ case bsontype.Null:
+ case bsontype.Regex:
+ pattern, options := v.Regex()
+ dst = bsoncore.AppendRegex(dst, pattern, options)
+ case bsontype.DBPointer:
+ ns, ptr := v.DBPointer()
+ dst = bsoncore.AppendDBPointer(dst, ns, ptr)
+ case bsontype.JavaScript:
+ dst = bsoncore.AppendJavaScript(dst, string(v.JavaScript()))
+ case bsontype.Symbol:
+ dst = bsoncore.AppendSymbol(dst, string(v.Symbol()))
+ case bsontype.CodeWithScope:
+ code, doc := v.CodeWithScope()
+ var scope []byte
+ scope, _ = doc.MarshalBSON() // Doc.MarshalBSON never returns an error.
+ dst = bsoncore.AppendCodeWithScope(dst, code, scope)
+ case bsontype.Int32:
+ dst = bsoncore.AppendInt32(dst, v.Int32())
+ case bsontype.Timestamp:
+ t, i := v.Timestamp()
+ dst = bsoncore.AppendTimestamp(dst, t, i)
+ case bsontype.Int64:
+ dst = bsoncore.AppendInt64(dst, v.Int64())
+ case bsontype.Decimal128:
+ dst = bsoncore.AppendDecimal128(dst, v.Decimal128())
+ case bsontype.MinKey:
+ case bsontype.MaxKey:
+ default:
+ panic(fmt.Errorf("invalid BSON type %v", t))
+ }
+
+ return t, dst, nil
+}
+
+// UnmarshalBSONValue implements the bsoncodec.ValueUnmarshaler interface.
+func (v *Val) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
+ if v == nil {
+ return errors.New("cannot unmarshal into nil Value")
+ }
+ var err error
+ var ok = true
+ var rem []byte
+ switch t {
+ case bsontype.Double:
+ var f64 float64
+ f64, rem, ok = bsoncore.ReadDouble(data)
+ *v = Double(f64)
+ case bsontype.String:
+ var str string
+ str, rem, ok = bsoncore.ReadString(data)
+ *v = String(str)
+ case bsontype.EmbeddedDocument:
+ var raw []byte
+ var doc Doc
+ raw, rem, ok = bsoncore.ReadDocument(data)
+ doc, err = ReadDoc(raw)
+ *v = Document(doc)
+ case bsontype.Array:
+ var raw []byte
+ arr := make(Arr, 0)
+ raw, rem, ok = bsoncore.ReadArray(data)
+ err = arr.UnmarshalBSONValue(t, raw)
+ *v = Array(arr)
+ case bsontype.Binary:
+ var subtype byte
+ var bindata []byte
+ subtype, bindata, rem, ok = bsoncore.ReadBinary(data)
+ *v = Binary(subtype, bindata)
+ case bsontype.Undefined:
+ *v = Undefined()
+ case bsontype.ObjectID:
+ var oid primitive.ObjectID
+ oid, rem, ok = bsoncore.ReadObjectID(data)
+ *v = ObjectID(oid)
+ case bsontype.Boolean:
+ var b bool
+ b, rem, ok = bsoncore.ReadBoolean(data)
+ *v = Boolean(b)
+ case bsontype.DateTime:
+ var dt int64
+ dt, rem, ok = bsoncore.ReadDateTime(data)
+ *v = DateTime(dt)
+ case bsontype.Null:
+ *v = Null()
+ case bsontype.Regex:
+ var pattern, options string
+ pattern, options, rem, ok = bsoncore.ReadRegex(data)
+ *v = Regex(pattern, options)
+ case bsontype.DBPointer:
+ var ns string
+ var ptr primitive.ObjectID
+ ns, ptr, rem, ok = bsoncore.ReadDBPointer(data)
+ *v = DBPointer(ns, ptr)
+ case bsontype.JavaScript:
+ var js string
+ js, rem, ok = bsoncore.ReadJavaScript(data)
+ *v = JavaScript(js)
+ case bsontype.Symbol:
+ var symbol string
+ symbol, rem, ok = bsoncore.ReadSymbol(data)
+ *v = Symbol(symbol)
+ case bsontype.CodeWithScope:
+ var raw []byte
+ var code string
+ var scope Doc
+ code, raw, rem, ok = bsoncore.ReadCodeWithScope(data)
+ scope, err = ReadDoc(raw)
+ *v = CodeWithScope(code, scope)
+ case bsontype.Int32:
+ var i32 int32
+ i32, rem, ok = bsoncore.ReadInt32(data)
+ *v = Int32(i32)
+ case bsontype.Timestamp:
+ var i, t uint32
+ t, i, rem, ok = bsoncore.ReadTimestamp(data)
+ *v = Timestamp(t, i)
+ case bsontype.Int64:
+ var i64 int64
+ i64, rem, ok = bsoncore.ReadInt64(data)
+ *v = Int64(i64)
+ case bsontype.Decimal128:
+ var d128 primitive.Decimal128
+ d128, rem, ok = bsoncore.ReadDecimal128(data)
+ *v = Decimal128(d128)
+ case bsontype.MinKey:
+ *v = MinKey()
+ case bsontype.MaxKey:
+ *v = MaxKey()
+ default:
+ err = fmt.Errorf("invalid BSON type %v", t)
+ }
+
+ if !ok && err == nil {
+ err = bsoncore.NewInsufficientBytesError(data, rem)
+ }
+
+ return err
+}
+
+// Type returns the BSON type of this value.
+func (v Val) Type() bsontype.Type {
+ if v.t == bsontype.Type(0) {
+ return bsontype.Null
+ }
+ return v.t
+}
+
+// IsNumber returns true if the type of v is a numberic BSON type.
+func (v Val) IsNumber() bool {
+ switch v.Type() {
+ case bsontype.Double, bsontype.Int32, bsontype.Int64, bsontype.Decimal128:
+ return true
+ default:
+ return false
+ }
+}
+
+// Double returns the BSON double value the Value represents. It panics if the value is a BSON type
+// other than double.
+func (v Val) Double() float64 {
+ if v.t != bsontype.Double {
+ panic(ElementTypeError{"bson.Value.Double", v.t})
+ }
+ return math.Float64frombits(binary.LittleEndian.Uint64(v.bootstrap[0:8]))
+}
+
+// DoubleOK is the same as Double, but returns a boolean instead of panicking.
+func (v Val) DoubleOK() (float64, bool) {
+ if v.t != bsontype.Double {
+ return 0, false
+ }
+ return math.Float64frombits(binary.LittleEndian.Uint64(v.bootstrap[0:8])), true
+}
+
+// StringValue returns the BSON string the Value represents. It panics if the value is a BSON type
+// other than string.
+//
+// NOTE: This method is called StringValue to avoid it implementing the
+// fmt.Stringer interface.
+func (v Val) StringValue() string {
+ if v.t != bsontype.String {
+ panic(ElementTypeError{"bson.Value.StringValue", v.t})
+ }
+ return v.string()
+}
+
+// StringValueOK is the same as StringValue, but returns a boolean instead of
+// panicking.
+func (v Val) StringValueOK() (string, bool) {
+ if v.t != bsontype.String {
+ return "", false
+ }
+ return v.string(), true
+}
+
+func (v Val) asDoc() Doc {
+ doc, ok := v.primitive.(Doc)
+ if ok {
+ return doc
+ }
+ mdoc := v.primitive.(MDoc)
+ for k, v := range mdoc {
+ doc = append(doc, Elem{k, v})
+ }
+ return doc
+}
+
+func (v Val) asMDoc() MDoc {
+ mdoc, ok := v.primitive.(MDoc)
+ if ok {
+ return mdoc
+ }
+ doc := v.primitive.(Doc)
+ for _, elem := range doc {
+ mdoc[elem.Key] = elem.Value
+ }
+ return mdoc
+}
+
+// Document returns the BSON embedded document value the Value represents. It panics if the value
+// is a BSON type other than embedded document.
+func (v Val) Document() Doc {
+ if v.t != bsontype.EmbeddedDocument {
+ panic(ElementTypeError{"bson.Value.Document", v.t})
+ }
+ return v.asDoc()
+}
+
+// DocumentOK is the same as Document, except it returns a boolean
+// instead of panicking.
+func (v Val) DocumentOK() (Doc, bool) {
+ if v.t != bsontype.EmbeddedDocument {
+ return nil, false
+ }
+ return v.asDoc(), true
+}
+
+// MDocument returns the BSON embedded document value the Value represents. It panics if the value
+// is a BSON type other than embedded document.
+func (v Val) MDocument() MDoc {
+ if v.t != bsontype.EmbeddedDocument {
+ panic(ElementTypeError{"bson.Value.MDocument", v.t})
+ }
+ return v.asMDoc()
+}
+
+// MDocumentOK is the same as Document, except it returns a boolean
+// instead of panicking.
+func (v Val) MDocumentOK() (MDoc, bool) {
+ if v.t != bsontype.EmbeddedDocument {
+ return nil, false
+ }
+ return v.asMDoc(), true
+}
+
+// Array returns the BSON array value the Value represents. It panics if the value is a BSON type
+// other than array.
+func (v Val) Array() Arr {
+ if v.t != bsontype.Array {
+ panic(ElementTypeError{"bson.Value.Array", v.t})
+ }
+ return v.primitive.(Arr)
+}
+
+// ArrayOK is the same as Array, except it returns a boolean
+// instead of panicking.
+func (v Val) ArrayOK() (Arr, bool) {
+ if v.t != bsontype.Array {
+ return nil, false
+ }
+ return v.primitive.(Arr), true
+}
+
+// Binary returns the BSON binary value the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (v Val) Binary() (byte, []byte) {
+ if v.t != bsontype.Binary {
+ panic(ElementTypeError{"bson.Value.Binary", v.t})
+ }
+ bin := v.primitive.(primitive.Binary)
+ return bin.Subtype, bin.Data
+}
+
+// BinaryOK is the same as Binary, except it returns a boolean instead of
+// panicking.
+func (v Val) BinaryOK() (byte, []byte, bool) {
+ if v.t != bsontype.Binary {
+ return 0x00, nil, false
+ }
+ bin := v.primitive.(primitive.Binary)
+ return bin.Subtype, bin.Data, true
+}
+
+// Undefined returns the BSON undefined the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (v Val) Undefined() {
+ if v.t != bsontype.Undefined {
+ panic(ElementTypeError{"bson.Value.Undefined", v.t})
+ }
+ return
+}
+
+// UndefinedOK is the same as Undefined, except it returns a boolean instead of
+// panicking.
+func (v Val) UndefinedOK() bool {
+ if v.t != bsontype.Undefined {
+ return false
+ }
+ return true
+}
+
+// ObjectID returns the BSON ObjectID the Value represents. It panics if the value is a BSON type
+// other than ObjectID.
+func (v Val) ObjectID() primitive.ObjectID {
+ if v.t != bsontype.ObjectID {
+ panic(ElementTypeError{"bson.Value.ObjectID", v.t})
+ }
+ var oid primitive.ObjectID
+ copy(oid[:], v.bootstrap[:12])
+ return oid
+}
+
+// ObjectIDOK is the same as ObjectID, except it returns a boolean instead of
+// panicking.
+func (v Val) ObjectIDOK() (primitive.ObjectID, bool) {
+ if v.t != bsontype.ObjectID {
+ return primitive.ObjectID{}, false
+ }
+ var oid primitive.ObjectID
+ copy(oid[:], v.bootstrap[:12])
+ return oid, true
+}
+
+// Boolean returns the BSON boolean the Value represents. It panics if the value is a BSON type
+// other than boolean.
+func (v Val) Boolean() bool {
+ if v.t != bsontype.Boolean {
+ panic(ElementTypeError{"bson.Value.Boolean", v.t})
+ }
+ return v.bootstrap[0] == 0x01
+}
+
+// BooleanOK is the same as Boolean, except it returns a boolean instead of
+// panicking.
+func (v Val) BooleanOK() (bool, bool) {
+ if v.t != bsontype.Boolean {
+ return false, false
+ }
+ return v.bootstrap[0] == 0x01, true
+}
+
+// DateTime returns the BSON datetime the Value represents. It panics if the value is a BSON type
+// other than datetime.
+func (v Val) DateTime() int64 {
+ if v.t != bsontype.DateTime {
+ panic(ElementTypeError{"bson.Value.DateTime", v.t})
+ }
+ return v.i64()
+}
+
+// DateTimeOK is the same as DateTime, except it returns a boolean instead of
+// panicking.
+func (v Val) DateTimeOK() (int64, bool) {
+ if v.t != bsontype.DateTime {
+ return 0, false
+ }
+ return v.i64(), true
+}
+
+// Time returns the BSON datetime the Value represents as time.Time. It panics if the value is a BSON
+// type other than datetime.
+func (v Val) Time() time.Time {
+ if v.t != bsontype.DateTime {
+ panic(ElementTypeError{"bson.Value.Time", v.t})
+ }
+ i := v.i64()
+ return time.Unix(int64(i)/1000, int64(i)%1000*1000000)
+}
+
+// TimeOK is the same as Time, except it returns a boolean instead of
+// panicking.
+func (v Val) TimeOK() (time.Time, bool) {
+ if v.t != bsontype.DateTime {
+ return time.Time{}, false
+ }
+ i := v.i64()
+ return time.Unix(int64(i)/1000, int64(i)%1000*1000000), true
+}
+
+// Null returns the BSON undefined the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (v Val) Null() {
+ if v.t != bsontype.Null && v.t != bsontype.Type(0) {
+ panic(ElementTypeError{"bson.Value.Null", v.t})
+ }
+ return
+}
+
+// NullOK is the same as Null, except it returns a boolean instead of
+// panicking.
+func (v Val) NullOK() bool {
+ if v.t != bsontype.Null && v.t != bsontype.Type(0) {
+ return false
+ }
+ return true
+}
+
+// Regex returns the BSON regex the Value represents. It panics if the value is a BSON type
+// other than regex.
+func (v Val) Regex() (pattern, options string) {
+ if v.t != bsontype.Regex {
+ panic(ElementTypeError{"bson.Value.Regex", v.t})
+ }
+ regex := v.primitive.(primitive.Regex)
+ return regex.Pattern, regex.Options
+}
+
+// RegexOK is the same as Regex, except that it returns a boolean
+// instead of panicking.
+func (v Val) RegexOK() (pattern, options string, ok bool) {
+ if v.t != bsontype.Regex {
+ return "", "", false
+ }
+ regex := v.primitive.(primitive.Regex)
+ return regex.Pattern, regex.Options, true
+}
+
+// DBPointer returns the BSON dbpointer the Value represents. It panics if the value is a BSON type
+// other than dbpointer.
+func (v Val) DBPointer() (string, primitive.ObjectID) {
+ if v.t != bsontype.DBPointer {
+ panic(ElementTypeError{"bson.Value.DBPointer", v.t})
+ }
+ dbptr := v.primitive.(primitive.DBPointer)
+ return dbptr.DB, dbptr.Pointer
+}
+
+// DBPointerOK is the same as DBPoitner, except that it returns a boolean
+// instead of panicking.
+func (v Val) DBPointerOK() (string, primitive.ObjectID, bool) {
+ if v.t != bsontype.DBPointer {
+ return "", primitive.ObjectID{}, false
+ }
+ dbptr := v.primitive.(primitive.DBPointer)
+ return dbptr.DB, dbptr.Pointer, true
+}
+
+// JavaScript returns the BSON JavaScript the Value represents. It panics if the value is a BSON type
+// other than JavaScript.
+func (v Val) JavaScript() string {
+ if v.t != bsontype.JavaScript {
+ panic(ElementTypeError{"bson.Value.JavaScript", v.t})
+ }
+ return v.string()
+}
+
+// JavaScriptOK is the same as Javascript, except that it returns a boolean
+// instead of panicking.
+func (v Val) JavaScriptOK() (string, bool) {
+ if v.t != bsontype.JavaScript {
+ return "", false
+ }
+ return v.string(), true
+}
+
+// Symbol returns the BSON symbol the Value represents. It panics if the value is a BSON type
+// other than symbol.
+func (v Val) Symbol() string {
+ if v.t != bsontype.Symbol {
+ panic(ElementTypeError{"bson.Value.Symbol", v.t})
+ }
+ return v.string()
+}
+
+// SymbolOK is the same as Javascript, except that it returns a boolean
+// instead of panicking.
+func (v Val) SymbolOK() (string, bool) {
+ if v.t != bsontype.Symbol {
+ return "", false
+ }
+ return v.string(), true
+}
+
+// CodeWithScope returns the BSON code with scope value the Value represents. It panics if the
+// value is a BSON type other than code with scope.
+func (v Val) CodeWithScope() (string, Doc) {
+ if v.t != bsontype.CodeWithScope {
+ panic(ElementTypeError{"bson.Value.CodeWithScope", v.t})
+ }
+ cws := v.primitive.(primitive.CodeWithScope)
+ return string(cws.Code), cws.Scope.(Doc)
+}
+
+// CodeWithScopeOK is the same as JavascriptWithScope,
+// except that it returns a boolean instead of panicking.
+func (v Val) CodeWithScopeOK() (string, Doc, bool) {
+ if v.t != bsontype.CodeWithScope {
+ return "", nil, false
+ }
+ cws := v.primitive.(primitive.CodeWithScope)
+ return string(cws.Code), cws.Scope.(Doc), true
+}
+
+// Int32 returns the BSON int32 the Value represents. It panics if the value is a BSON type
+// other than int32.
+func (v Val) Int32() int32 {
+ if v.t != bsontype.Int32 {
+ panic(ElementTypeError{"bson.Value.Int32", v.t})
+ }
+ return int32(v.bootstrap[0]) | int32(v.bootstrap[1])<<8 |
+ int32(v.bootstrap[2])<<16 | int32(v.bootstrap[3])<<24
+}
+
+// Int32OK is the same as Int32, except that it returns a boolean instead of
+// panicking.
+func (v Val) Int32OK() (int32, bool) {
+ if v.t != bsontype.Int32 {
+ return 0, false
+ }
+ return int32(v.bootstrap[0]) | int32(v.bootstrap[1])<<8 |
+ int32(v.bootstrap[2])<<16 | int32(v.bootstrap[3])<<24,
+ true
+}
+
+// Timestamp returns the BSON timestamp the Value represents. It panics if the value is a
+// BSON type other than timestamp.
+func (v Val) Timestamp() (t, i uint32) {
+ if v.t != bsontype.Timestamp {
+ panic(ElementTypeError{"bson.Value.Timestamp", v.t})
+ }
+ return uint32(v.bootstrap[4]) | uint32(v.bootstrap[5])<<8 |
+ uint32(v.bootstrap[6])<<16 | uint32(v.bootstrap[7])<<24,
+ uint32(v.bootstrap[0]) | uint32(v.bootstrap[1])<<8 |
+ uint32(v.bootstrap[2])<<16 | uint32(v.bootstrap[3])<<24
+}
+
+// TimestampOK is the same as Timestamp, except that it returns a boolean
+// instead of panicking.
+func (v Val) TimestampOK() (t uint32, i uint32, ok bool) {
+ if v.t != bsontype.Timestamp {
+ return 0, 0, false
+ }
+ return uint32(v.bootstrap[4]) | uint32(v.bootstrap[5])<<8 |
+ uint32(v.bootstrap[6])<<16 | uint32(v.bootstrap[7])<<24,
+ uint32(v.bootstrap[0]) | uint32(v.bootstrap[1])<<8 |
+ uint32(v.bootstrap[2])<<16 | uint32(v.bootstrap[3])<<24,
+ true
+}
+
+// Int64 returns the BSON int64 the Value represents. It panics if the value is a BSON type
+// other than int64.
+func (v Val) Int64() int64 {
+ if v.t != bsontype.Int64 {
+ panic(ElementTypeError{"bson.Value.Int64", v.t})
+ }
+ return v.i64()
+}
+
+// Int64OK is the same as Int64, except that it returns a boolean instead of
+// panicking.
+func (v Val) Int64OK() (int64, bool) {
+ if v.t != bsontype.Int64 {
+ return 0, false
+ }
+ return v.i64(), true
+}
+
+// Decimal128 returns the BSON decimal128 value the Value represents. It panics if the value is a
+// BSON type other than decimal128.
+func (v Val) Decimal128() primitive.Decimal128 {
+ if v.t != bsontype.Decimal128 {
+ panic(ElementTypeError{"bson.Value.Decimal128", v.t})
+ }
+ return v.primitive.(primitive.Decimal128)
+}
+
+// Decimal128OK is the same as Decimal128, except that it returns a boolean
+// instead of panicking.
+func (v Val) Decimal128OK() (primitive.Decimal128, bool) {
+ if v.t != bsontype.Decimal128 {
+ return primitive.Decimal128{}, false
+ }
+ return v.primitive.(primitive.Decimal128), true
+}
+
+// MinKey returns the BSON minkey the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (v Val) MinKey() {
+ if v.t != bsontype.MinKey {
+ panic(ElementTypeError{"bson.Value.MinKey", v.t})
+ }
+ return
+}
+
+// MinKeyOK is the same as MinKey, except it returns a boolean instead of
+// panicking.
+func (v Val) MinKeyOK() bool {
+ if v.t != bsontype.MinKey {
+ return false
+ }
+ return true
+}
+
+// MaxKey returns the BSON maxkey the Value represents. It panics if the value is a BSON type
+// other than binary.
+func (v Val) MaxKey() {
+ if v.t != bsontype.MaxKey {
+ panic(ElementTypeError{"bson.Value.MaxKey", v.t})
+ }
+ return
+}
+
+// MaxKeyOK is the same as MaxKey, except it returns a boolean instead of
+// panicking.
+func (v Val) MaxKeyOK() bool {
+ if v.t != bsontype.MaxKey {
+ return false
+ }
+ return true
+}
+
+// Equal compares v to v2 and returns true if they are equal. Unknown BSON types are
+// never equal. Two empty values are equal.
+func (v Val) Equal(v2 Val) bool {
+ if v.Type() != v2.Type() {
+ return false
+ }
+ if v.IsZero() && v2.IsZero() {
+ return true
+ }
+
+ switch v.Type() {
+ case bsontype.Double, bsontype.DateTime, bsontype.Timestamp, bsontype.Int64:
+ return bytes.Equal(v.bootstrap[0:8], v2.bootstrap[0:8])
+ case bsontype.String:
+ return v.string() == v2.string()
+ case bsontype.EmbeddedDocument:
+ return v.equalDocs(v2)
+ case bsontype.Array:
+ return v.Array().Equal(v2.Array())
+ case bsontype.Binary:
+ return v.primitive.(primitive.Binary).Equal(v2.primitive.(primitive.Binary))
+ case bsontype.Undefined:
+ return true
+ case bsontype.ObjectID:
+ return bytes.Equal(v.bootstrap[0:12], v2.bootstrap[0:12])
+ case bsontype.Boolean:
+ return v.bootstrap[0] == v2.bootstrap[0]
+ case bsontype.Null:
+ return true
+ case bsontype.Regex:
+ return v.primitive.(primitive.Regex).Equal(v2.primitive.(primitive.Regex))
+ case bsontype.DBPointer:
+ return v.primitive.(primitive.DBPointer).Equal(v2.primitive.(primitive.DBPointer))
+ case bsontype.JavaScript:
+ return v.JavaScript() == v2.JavaScript()
+ case bsontype.Symbol:
+ return v.Symbol() == v2.Symbol()
+ case bsontype.CodeWithScope:
+ code1, scope1 := v.primitive.(primitive.CodeWithScope).Code, v.primitive.(primitive.CodeWithScope).Scope
+ code2, scope2 := v2.primitive.(primitive.CodeWithScope).Code, v2.primitive.(primitive.CodeWithScope).Scope
+ return code1 == code2 && v.equalInterfaceDocs(scope1, scope2)
+ case bsontype.Int32:
+ return v.Int32() == v2.Int32()
+ case bsontype.Decimal128:
+ h, l := v.Decimal128().GetBytes()
+ h2, l2 := v2.Decimal128().GetBytes()
+ return h == h2 && l == l2
+ case bsontype.MinKey:
+ return true
+ case bsontype.MaxKey:
+ return true
+ default:
+ return false
+ }
+}
+
+func (v Val) equalDocs(v2 Val) bool {
+ _, ok1 := v.primitive.(MDoc)
+ _, ok2 := v2.primitive.(MDoc)
+ if ok1 || ok2 {
+ return v.asMDoc().Equal(v2.asMDoc())
+ }
+ return v.asDoc().Equal(v2.asDoc())
+}
+
+func (Val) equalInterfaceDocs(i, i2 interface{}) bool {
+ switch d := i.(type) {
+ case MDoc:
+ d2, ok := i2.(IDoc)
+ if !ok {
+ return false
+ }
+ return d.Equal(d2)
+ case Doc:
+ d2, ok := i2.(IDoc)
+ if !ok {
+ return false
+ }
+ return d.Equal(d2)
+ case nil:
+ return i2 == nil
+ default:
+ return false
+ }
+}