bsonobj.h

// @file bsonobj.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 <boost/noncopyable.hpp>
#include <set>
#include <list>
#include <string>
#include <vector>
#include <utility>

#include "mongo/bson/bsonelement.h"
#include "mongo/base/data_view.h"
#include "mongo/base/string_data.h"
#include "mongo/bson/util/builder.h"
#include "mongo/client/export_macros.h"
#include "mongo/platform/atomic_word.h"
#include "mongo/util/shared_buffer.h"

namespace mongo {

    typedef std::set< BSONElement, BSONElementCmpWithoutField > BSONElementSet;
    typedef std::multiset< BSONElement, BSONElementCmpWithoutField > BSONElementMSet;

    class MONGO_CLIENT_API BSONObj {
    public:

        BSONObj() {
            // Little endian ordering here, but that is ok regardless as BSON is spec'd to be
            // little endian external to the system. (i.e. the rest of the implementation of
            // bson, not this part, fails to support big endian)
            static const char kEmptyObjectPrototype[] = { /*size*/5, 0, 0, 0, /*eoo*/0 };
            _objdata = kEmptyObjectPrototype;
        }

        explicit BSONObj(const char *bsonData) {
            init(bsonData);
        }

        explicit BSONObj(SharedBuffer ownedBuffer)
                : _objdata(ownedBuffer.get() ? ownedBuffer.get() : BSONObj().objdata())
                , _ownedBuffer(ownedBuffer.moveFrom()) {
        }

#if __cplusplus >= 201103L

        BSONObj(BSONObj&& other)
            : _objdata(std::move(other._objdata))
            , _ownedBuffer(std::move(other._ownedBuffer)) {
            other._objdata = BSONObj()._objdata; // To return to an empty state.
        }

        // The explicit move constructor above will inhibit generation of the copy ctor, so
        // explicitly request the default implementation.

        BSONObj(const BSONObj&) = default;
#endif

        BSONObj& operator=(BSONObj otherCopy) {
            this->swap(otherCopy);
            return *this;
        }

        void swap(BSONObj& other) {
            using std::swap;
            swap(_objdata, other._objdata);
            swap(_ownedBuffer, other._ownedBuffer);
        }

        bool isOwned() const { return _ownedBuffer.get() != 0; }

        BSONObj getOwned() const;

        BSONObj copy() const;

        enum { maxToStringRecursionDepth = 100 };

        std::string toString( bool isArray = false, bool full=false ) const;
        void toString( StringBuilder& s, bool isArray = false, bool full=false, int depth=0 ) const;

        std::string jsonString(
            JsonStringFormat format = Strict,
            int pretty = 0,
            bool isArray = false
        ) const;

        int addFields(BSONObj& from, std::set<std::string>& fields); /* returns n added */

        BSONObj removeField(const StringData& name) const;

        int nFields() const;

        int getFieldNames(std::set<std::string>& fields) const;

        BSONElement getFieldDotted(const StringData &name) const;

        void getFieldsDotted(const StringData& name, BSONElementSet &ret, bool expandLastArray = true ) const;
        void getFieldsDotted(const StringData& name, BSONElementMSet &ret, bool expandLastArray = true ) const;

        BSONElement getFieldDottedOrArray(const char *&name) const;

        BSONElement getField(const StringData& name) const;

        void getFields(unsigned n, const char **fieldNames, BSONElement *fields) const;

        BSONElement operator[] (const StringData& field) const {
            return getField(field);
        }

        BSONElement operator[] (int field) const {
            StringBuilder ss;
            ss << field;
            std::string s = ss.str();
            return getField(s.c_str());
        }

        bool hasField( const StringData& name ) const { return !getField(name).eoo(); }
        bool hasElement(const StringData& name) const { return hasField(name); }

        const char * getStringField(const StringData& name) const;

        BSONObj getObjectField(const StringData& name) const;

        int getIntField(const StringData& name) const;

        bool getBoolField(const StringData& name) const;

        BSONObj extractFieldsUnDotted(const BSONObj& pattern) const;

        BSONObj extractFields(const BSONObj &pattern , bool fillWithNull=false) const;

        BSONObj filterFieldsUndotted(const BSONObj &filter, bool inFilter) const;

        BSONElement getFieldUsingIndexNames(const StringData& fieldName,
                                            const BSONObj &indexKey) const;

        bool couldBeArray() const;

        const char *objdata() const {
            return _objdata;
        }

        int objsize() const {
            return ConstDataView(objdata()).readLE<int>();
        }

        bool isValid() const {
            int x = objsize();
            return x > 0 && x <= BSONObjMaxInternalSize;
        }

        inline bool okForStorage() const {
            return _okForStorage(false, true).isOK();
        }

        inline bool okForStorageAsRoot() const {
            return _okForStorage(true, true).isOK();
        }

        inline Status storageValidEmbedded(const bool deep = true) const {
            return _okForStorage(false, deep);
        }

        inline Status storageValid(const bool deep = true) const {
            return _okForStorage(true, deep);
        }

        bool isEmpty() const { return objsize() <= 5; }

        void dump() const;

        std::string hexDump() const;

        int woCompare(const BSONObj& r, const Ordering &o,
                      bool considerFieldName=true) const;

        int woCompare(const BSONObj& r, const BSONObj &ordering = BSONObj(),
                      bool considerFieldName=true) const;

        bool operator<( const BSONObj& other ) const { return woCompare( other ) < 0; }
        bool operator<=( const BSONObj& other ) const { return woCompare( other ) <= 0; }
        bool operator>( const BSONObj& other ) const { return woCompare( other ) > 0; }
        bool operator>=( const BSONObj& other ) const { return woCompare( other ) >= 0; }

        int woSortOrder( const BSONObj& r , const BSONObj& sortKey , bool useDotted=false ) const;

        bool equal(const BSONObj& r) const;

        struct Hasher {
            size_t operator() (const BSONObj& obj) const;
        };

        bool isPrefixOf( const BSONObj& otherObj ) const;

        bool isFieldNamePrefixOf( const BSONObj& otherObj ) const;

        bool binaryEqual(const BSONObj& r) const {
            int os = objsize();
            if ( os == r.objsize() ) {
                return (os == 0 || memcmp(objdata(),r.objdata(),os)==0);
            }
            return false;
        }

        BSONElement firstElement() const { return BSONElement(objdata() + 4); }

        const char * firstElementFieldName() const {
            const char *p = objdata() + 4;
            return *p == EOO ? "" : p+1;
        }

        BSONType firstElementType() const {
            const char *p = objdata() + 4;
            return (BSONType) *p;
        }

        bool getObjectID(BSONElement& e) const;

        // Return a version of this object where top level elements of types
        // that are not part of the bson wire protocol are replaced with
        // string identifier equivalents.
        // TODO Support conversion of element types other than min and max.
        BSONObj clientReadable() const;

        BSONObj replaceFieldNames( const BSONObj &obj ) const;

        bool valid() const;

        bool operator==( const BSONObj& other ) const { return equal( other ); }
        bool operator!=(const BSONObj& other) const { return !operator==( other); }

        enum MatchType {
            Equality = 0,
            LT = 0x1,
            LTE = 0x3,
            GTE = 0x6,
            GT = 0x4,
            opIN = 0x8, // { x : { $in : [1,2,3] } }
            NE = 0x9,
            opSIZE = 0x0A,
            opALL = 0x0B,
            NIN = 0x0C,
            opEXISTS = 0x0D,
            opMOD = 0x0E,
            opTYPE = 0x0F,
            opREGEX = 0x10,
            opOPTIONS = 0x11,
            opELEM_MATCH = 0x12,
            opNEAR = 0x13,
            opWITHIN = 0x14,
            opMAX_DISTANCE = 0x15,
            opGEO_INTERSECTS = 0x16,
        };

        void elems(std::vector<BSONElement> &) const;
        void elems(std::list<BSONElement> &) const;

        friend class BSONObjIterator;
        typedef BSONObjIterator iterator;

        BSONObjIterator begin() const;

        void appendSelfToBufBuilder(BufBuilder& b) const {
            verify( objsize() );
            b.appendBuf(objdata(), objsize());
        }

        template<typename T> bool coerceVector( std::vector<T>* out ) const;

        typedef SharedBuffer::Holder Holder;

        static BSONObj takeOwnership(char* holderPrefixedData) {
            return BSONObj(SharedBuffer::takeOwnership(holderPrefixedData));
        }

    private:
        void _assertInvalid() const;

        void init(const char *data) {
            _objdata = data;
            if ( !isValid() )
                _assertInvalid();
        }

        Status _okForStorage(bool root, bool deep) const;

        const char* _objdata;
        SharedBuffer _ownedBuffer;
    };

    MONGO_CLIENT_API std::ostream& MONGO_CLIENT_FUNC operator<<( std::ostream &s, const BSONObj &o );
    MONGO_CLIENT_API std::ostream& MONGO_CLIENT_FUNC operator<<( std::ostream &s, const BSONElement &e );

    MONGO_CLIENT_API StringBuilder& MONGO_CLIENT_FUNC operator<<( StringBuilder &s, const BSONObj &o );
    MONGO_CLIENT_API StringBuilder& MONGO_CLIENT_FUNC operator<<( StringBuilder &s, const BSONElement &e );

    inline void swap(BSONObj& l, BSONObj& r) {
        l.swap(r);
    }

    struct BSONArray : BSONObj {
        // Don't add anything other than forwarding constructors!!!
        BSONArray(): BSONObj() {}
        explicit BSONArray(const BSONObj& obj): BSONObj(obj) {}
    };

}