bsonelement.h

// bsonelement.h
 
/*    Copyright 2009 10gen Inc.
 *
 *    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
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
 
#pragma once
 
#include <string.h>  // strlen
#include <string>
#include <vector>
 
#include "mongo/base/data_cursor.h"
#include "mongo/bson/bsontypes.h"
#include "mongo/bson/oid.h"
#include "mongo/bson/timestamp.h"
#include "mongo/client/export_macros.h"
#include "mongo/platform/cstdint.h"
#include "mongo/platform/float_utils.h"
#include "mongo/platform/strnlen.h"
 
namespace mongo {
class BSONObj;
class BSONElement;
class BSONObjBuilder;
 
/* l and r MUST have same type when called: check that first. */
int compareElementValues(const BSONElement& l, const BSONElement& r);
 
 
class MONGO_CLIENT_API BSONElement {
public:
    std::string String() const {
        return chk(mongo::String).str();
    }
    const StringData checkAndGetStringData() const {
        return chk(mongo::String).valueStringData();
    }
    Date_t Date() const {
        return chk(mongo::Date).date();
    }
    double Number() const {
        return chk(isNumber()).number();
    }
    double Double() const {
        return chk(NumberDouble)._numberDouble();
    }
    long long Long() const {
        return chk(NumberLong)._numberLong();
    }
    int Int() const {
        return chk(NumberInt)._numberInt();
    }
    bool Bool() const {
        return chk(mongo::Bool).boolean();
    }
    std::vector<BSONElement> Array() const;  // see implementation for detailed comments
    mongo::OID OID() const {
        return chk(jstOID).__oid();
    }
    void Null() const {
        chk(isNull());
    }  // throw MsgAssertionException if not null
    void OK() const {
        chk(ok());
    }  // throw MsgAssertionException if element DNE
    Timestamp_t Timestamp() const {
        return chk(mongo::Timestamp).timestamp();
    }
 
    BSONObj Obj() const;
 
    void Val(Date_t& v) const {
        v = Date();
    }
    void Val(long long& v) const {
        v = Long();
    }
    void Val(bool& v) const {
        v = Bool();
    }
    void Val(BSONObj& v) const;
    void Val(mongo::OID& v) const {
        v = OID();
    }
    void Val(int& v) const {
        v = Int();
    }
    void Val(double& v) const {
        v = Double();
    }
    void Val(std::string& v) const {
        v = String();
    }
 
    bool ok() const {
        return !eoo();
    }
 
    std::string toString(bool includeFieldName = true, bool full = false) const;
    void toString(StringBuilder& s,
                  bool includeFieldName = true,
                  bool full = false,
                  int depth = 0) const;
    std::string jsonString(JsonStringFormat format,
                           bool includeFieldNames = true,
                           int pretty = 0) const;
    operator std::string() const {
        return toString();
    }
 
    BSONType type() const {
        const signed char typeByte = ConstDataView(data).readLE<signed char>();
        return static_cast<BSONType>(typeByte);
    }
 
    BSONElement operator[](const std::string& field) const;
 
    int canonicalType() const {
        return canonicalizeBSONType(type());
    }
 
    bool eoo() const {
        return type() == EOO;
    }
 
    int size(int maxLen) const;
    int size() const;
 
    BSONObj wrap() const;
 
    BSONObj wrap(const StringData& newName) const;
 
    const char* fieldName() const {
        if (eoo())
            return "";  // no fieldname for it.
        return data + 1;
    }
 
    int fieldNameSize() const {
        if (fieldNameSize_ == -1)
            fieldNameSize_ = (int)strlen(fieldName()) + 1;
        return fieldNameSize_;
    }
 
    const StringData fieldNameStringData() const {
        return StringData(fieldName(), eoo() ? 0 : fieldNameSize() - 1);
    }
 
    const char* value() const {
        return (data + fieldNameSize() + 1);
    }
    int valuesize() const {
        return size() - fieldNameSize() - 1;
    }
 
    bool isBoolean() const {
        return type() == mongo::Bool;
    }
 
    bool boolean() const {
        return *value() ? true : false;
    }
 
    bool booleanSafe() const {
        return isBoolean() && boolean();
    }
 
    Date_t date() const {
        return Date_t(ConstDataView(value()).readLE<unsigned long long>());
    }
 
    bool trueValue() const;
 
    bool isSimpleType() const;
 
    bool isNumber() const;
 
    double _numberDouble() const {
        return ConstDataView(value()).readLE<double>();
    }
 
    int _numberInt() const {
        return ConstDataView(value()).readLE<int>();
    }
 
    long long _numberLong() const {
        return ConstDataView(value()).readLE<long long>();
    }
 
    int numberInt() const;
    long long numberLong() const;
 
    long long safeNumberLong() const;
 
    double numberDouble() const;
    double number() const {
        return numberDouble();
    }
 
    mongo::OID __oid() const {
        return OID::from(value());
    }
 
    bool isNull() const {
        return type() == jstNULL;
    }
 
    int valuestrsize() const {
        return ConstDataView(value()).readLE<int>();
    }
 
    // for objects the size *includes* the size of the size field
    size_t objsize() const {
        return ConstDataView(value()).readLE<uint32_t>();
    }
 
    const char* valuestr() const {
        return value() + 4;
    }
 
    const char* valuestrsafe() const {
        return type() == mongo::String ? valuestr() : "";
    }
    std::string str() const {
        return type() == mongo::String ? std::string(valuestr(), valuestrsize() - 1)
                                       : std::string();
    }
 
    const StringData valueStringData() const {
        return StringData(valuestr(), valuestrsize() - 1);
    }
 
    const char* codeWScopeCode() const {
        massert(16177, "not codeWScope", type() == CodeWScope);
        return value() + 4 + 4;  // two ints precede code (see BSON spec)
    }
 
    int codeWScopeCodeLen() const {
        massert(16178, "not codeWScope", type() == CodeWScope);
        return ConstDataView(value() + 4).readLE<int>();
    }
 
    const char* codeWScopeScopeDataUnsafe() const {
        // This can error if there are null chars in the codeWScopeCode
        return codeWScopeCode() + strlen(codeWScopeCode()) + 1;
    }
 
    /* Get the scope SavedContext of a CodeWScope data element.
     *
     * This is the corrected version of codeWScopeScopeDataUnsafe(),
     * but note that existing uses might rely on the behavior of
     * that function so be careful in choosing which version to use.
     */
    const char* codeWScopeScopeData() const {
        return codeWScopeCode() + codeWScopeCodeLen();
    }
 
    BSONObj embeddedObject() const;
 
    /* uasserts if not an object */
    BSONObj embeddedObjectUserCheck() const;
 
    BSONObj codeWScopeObject() const;
 
    const char* binData(int& len) const {
        // BinData: <int len> <byte subtype> <byte[len] data>
        verify(type() == BinData);
        len = valuestrsize();
        return value() + 5;
    }
    const char* binDataClean(int& len) const {
        // BinData: <int len> <byte subtype> <byte[len] data>
        if (binDataType() != ByteArrayDeprecated) {
            return binData(len);
        } else {
            // Skip extra size
            len = valuestrsize() - 4;
            return value() + 5 + 4;
        }
    }
 
    BinDataType binDataType() const {
        // BinData: <int len> <byte subtype> <byte[len] data>
        verify(type() == BinData);
        unsigned char c = (value() + 4)[0];
        return (BinDataType)c;
    }
 
    const char* regex() const {
        verify(type() == RegEx);
        return value();
    }
 
    const char* regexFlags() const {
        const char* p = regex();
        return p + strlen(p) + 1;
    }
 
    bool valuesEqual(const BSONElement& r) const {
        return woCompare(r, false) == 0;
    }
 
    bool operator==(const BSONElement& r) const {
        return woCompare(r, true) == 0;
    }
    bool operator!=(const BSONElement& r) const {
        return !operator==(r);
    }
 
    int woCompare(const BSONElement& e, bool considerFieldName = true) const;
 
    struct Hasher {
        size_t operator()(const BSONElement& elem) const;
    };
 
    const char* rawdata() const {
        return data;
    }
 
    int getGtLtOp(int def = 0) const;
 
    BSONElement();
 
    bool mayEncapsulate() const {
        switch (type()) {
            case Object:
            case mongo::Array:
            case CodeWScope:
                return true;
            default:
                return false;
        }
    }
 
    bool isABSONObj() const {
        switch (type()) {
            case Object:
            case mongo::Array:
                return true;
            default:
                return false;
        }
    }
 
    Timestamp_t timestamp() const {
        ConstDataCursor cursor(value());
        const uint32_t increment = cursor.readLEAndAdvance<uint32_t>();
        const uint32_t seconds = cursor.readLE<uint32_t>();
        return Timestamp_t(seconds, increment);
    }
 
    const char* dbrefNS() const {
        uassert(10063, "not a dbref", type() == DBRef);
        return value() + 4;
    }
 
    const mongo::OID dbrefOID() const {
        uassert(10064, "not a dbref", type() == DBRef);
        const char* start = value();
        start += 4 + ConstDataView(start).readLE<int>();
        return mongo::OID::from(start);
    }
 
    bool operator<(const BSONElement& other) const {
        int x = (int)canonicalType() - (int)other.canonicalType();
        if (x < 0)
            return true;
        else if (x > 0)
            return false;
        return compareElementValues(*this, other) < 0;
    }
 
    // @param maxLen don't scan more than maxLen bytes
    explicit BSONElement(const char* d, int maxLen) : data(d) {
        if (eoo()) {
            totalSize = 1;
            fieldNameSize_ = 0;
        } else {
            totalSize = -1;
            fieldNameSize_ = -1;
            if (maxLen != -1) {
                size_t size = strnlen(fieldName(), maxLen - 1);
                uassert(10333, "Invalid field name", size < size_t(maxLen - 1));
                fieldNameSize_ = size + 1;
            }
        }
    }
 
    explicit BSONElement(const char* d) : data(d) {
        fieldNameSize_ = -1;
        totalSize = -1;
        if (eoo()) {
            fieldNameSize_ = 0;
            totalSize = 1;
        }
    }
 
    struct FieldNameSizeTag {};  // For disambiguation with ctor taking 'maxLen' above.
 
    BSONElement(const char* d, int fieldNameSize, FieldNameSizeTag)
        : data(d),
          fieldNameSize_(fieldNameSize)  // internal size includes null terminator
          ,
          totalSize(-1) {}
 
    std::string _asCode() const;
 
    template <typename T>
    bool coerce(T* out) const;
 
private:
    const char* data;
    mutable int fieldNameSize_;  // cached value
 
    mutable int totalSize; /* caches the computed size */
 
    friend class BSONObjIterator;
    friend class BSONObj;
    const BSONElement& chk(int t) const {
        if (t != type()) {
            StringBuilder ss;
            if (eoo())
                ss << "field not found, expected type " << t;
            else
                ss << "wrong type for field (" << fieldName() << ") " << type() << " != " << t;
            msgasserted(13111, ss.str());
        }
        return *this;
    }
    const BSONElement& chk(bool expr) const {
        massert(13118, "unexpected or missing type value in BSON object", expr);
        return *this;
    }
};
 
inline bool BSONElement::trueValue() const {
    // NOTE Behavior changes must be replicated in Value::coerceToBool().
    switch (type()) {
        case NumberLong:
            return _numberLong() != 0;
        case NumberDouble:
            return _numberDouble() != 0;
        case NumberInt:
            return _numberInt() != 0;
        case mongo::Bool:
            return boolean();
        case EOO:
        case jstNULL:
        case Undefined:
            return false;
 
        default:
            ;
    }
    return true;
}
 
inline bool BSONElement::isNumber() const {
    switch (type()) {
        case NumberLong:
        case NumberDouble:
        case NumberInt:
            return true;
        default:
            return false;
    }
}
 
inline bool BSONElement::isSimpleType() const {
    switch (type()) {
        case NumberLong:
        case NumberDouble:
        case NumberInt:
        case mongo::String:
        case mongo::Bool:
        case mongo::Date:
        case jstOID:
            return true;
        default:
            return false;
    }
}
 
inline double BSONElement::numberDouble() const {
    switch (type()) {
        case NumberDouble:
            return _numberDouble();
        case NumberInt:
            return _numberInt();
        case NumberLong:
            return _numberLong();
        default:
            return 0;
    }
}
 
inline int BSONElement::numberInt() const {
    switch (type()) {
        case NumberDouble:
            return (int)_numberDouble();
        case NumberInt:
            return _numberInt();
        case NumberLong:
            return (int)_numberLong();
        default:
            return 0;
    }
}
 
inline long long BSONElement::numberLong() const {
    switch (type()) {
        case NumberDouble:
            return (long long)_numberDouble();
        case NumberInt:
            return _numberInt();
        case NumberLong:
            return _numberLong();
        default:
            return 0;
    }
}
 
inline long long BSONElement::safeNumberLong() const {
    double d;
    switch (type()) {
        case NumberDouble:
            d = numberDouble();
            if (isNaN(d)) {
                return 0;
            }
            if (d > (double)std::numeric_limits<long long>::max()) {
                return std::numeric_limits<long long>::max();
            }
            if (d < std::numeric_limits<long long>::min()) {
                return std::numeric_limits<long long>::min();
            }
        default:
            return numberLong();
    }
}
 
inline BSONElement::BSONElement() {
    static const char kEooElement[] = "";
    data = kEooElement;
    fieldNameSize_ = 0;
    totalSize = 1;
}
 
// TODO(SERVER-14596): move to a better place; take a StringData.
std::string escape(const std::string& s, bool escape_slash = false);
}