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