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);

}