bsonobj.h

Go to the documentation of this file.

/*    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
#if defined (SDB_ENGINE) || defined (SDB_CLIENT)
#include "core.hpp"
#include "oss.hpp"
#endif
//#include <boost/intrusive_ptr.hpp>
#include <set>
#include <list>
#include <vector>
#include "lib/atomic_int.h"
#include "util/builder.h"
#include "stringdata.h"
#include "bsonelement.h"
#include "bsonnoncopyable.h"
#include "bsonintrusiveptr.h"
#include "bsonDecimal.h"
namespace bson {
    typedef set< BSONElement, BSONElementCmpWithoutField > BSONElementSet;
    typedef multiset< BSONElement, BSONElementCmpWithoutField > BSONElementMSet;

#if defined (SDB_ENGINE) || defined (SDB_CLIENT)
    class BSONObj : public SDBObject {
#else
    class BSONObj {
#endif
    public:
        class Holder;
        explicit BSONObj(const char *msgdata, bool check=true) {
          //_holder = NULL ;
          init(msgdata, check);
        }

        explicit BSONObj(Holder* holder) {
            init(holder);
        }

        BSONObj();

        ~BSONObj()
        {
           /*defensive:*/
           _objdata = 0;
          /* if ( _holder )
           {
              _holder->dec() ;
              if ( _holder->isZero() )
                 free ( _holder ) ;
           }*/
        }

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

        BSONObj getOwned() const;

        BSONObj copy() const;

        string toString( bool isArray = false, bool full=false ) const;
        void toString(StringBuilder& s, bool isArray = false, bool full=false )
          const;

        string jsonString( JsonStringFormat format = Strict, int pretty = 0 )
          const;

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

        int nFields() const;

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

        BSONElement getFieldDotted(const char *name) const;
        BSONElement getFieldDotted(const string& name) const {
            return getFieldDotted( name.c_str() );
        }

        void getFieldsDotted(const StringData& name, BSONElementSet &ret) const;
        void getFieldsDotted(const StringData& name, BSONElementMSet &ret)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 char *field) const {
            return getField(field);
        }

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

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

        bool hasField( const char * name ) const
          { return !getField(name).eoo(); }
        bool hasElement(const char *name) const
          { return hasField(name); }

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

        BSONObj getObjectField(const char *name) const;

        int getIntField(const char *name) const;

        bool getBoolField(const char *name) const;

        BSONObj extractFieldsUnDotted(BSONObj pattern) const;

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

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

        BSONElement getFieldUsingIndexNames(const char *fieldName,
          const BSONObj &indexKey) const;

        const char *objdata() const {
            return _objdata;
        }
        int objsize() const
          { return *(reinterpret_cast<const int*>(objdata())); }

        bool isValid();

        bool okForStorage() const;

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

        void dump() const;

        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;

        bool shallowEqual(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;
        }

        bool getObjectID(BSONElement& e) const;

        int hash() const {
            unsigned x = 0;
            const char *p = objdata();
            for ( int i = 0; i < objsize(); i++ )
                x = x * 131 + p[i];
            return (x & 0x7fffffff) | 0x8000000; // must be > 0
        }

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

        string md5() const;

        bool operator==( const BSONObj& other ) const { return equal( 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,
            opISNULL=0x16
        };

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

        template <class T>
        void Vals(vector<T> &) const;
        template <class T>
        void Vals(list<T> &) const;

        template <class T>
        void vals(vector<T> &) const;
        template <class T>
        void vals(list<T> &) const;

        friend class BSONObjIterator;
        typedef BSONObjIterator iterator;

        BSONObjIterator begin() const;

        void appendSelfToBufBuilder(BufBuilder& b) const {
            assert( objsize() );
            b.appendBuf(reinterpret_cast<const void *>( objdata() ), objsize());
        }

#pragma pack(1)
        class Holder : bsonnoncopyable {
        private:
            Holder(); // this class should never be explicitly created
            mongo::AtomicUInt refCount;
        public:
            char data[4]; // start of object

            void zero() { refCount.zero(); }
            //void inc () { refCount++ ; }
            //void dec () { if(--refCount == 0){
            //                 free(this) ; } }
            //void dec () { --refCount ; }
            //bool isZero () { return 0 == refCount ; }
            // these are called automatically by boost::intrusive_ptr
            friend void intrusive_ptr_add_ref(Holder* h) { h->refCount++; }
            friend void intrusive_ptr_release(Holder* h) {
#if defined(_DEBUG) // cant use dassert or DEV here
                assert((int)h->refCount > 0); // make sure we haven't already freed the buffer
#endif
                if(--(h->refCount) == 0){
                    free(h);
                }
            }
        };
#pragma pack()

        void init(const char *data, bool check=true ) {
            _objdata = data;
            if ( check && !isValid() )
                _assertInvalid();
        }
    public:
        static void setJSCompatibility(bool compatible) {
            _jsCompatibility = compatible;
        }

        static bool getJSCompatibility() {
            return _jsCompatibility;
        }

    private:
        SDB_EXPORT static bool _jsCompatibility;


    private:
        const char *_objdata;
        //Holder *_holder ;
        bson_intrusive_ptr< Holder > _holder;

        void _assertInvalid() const;

        void init(Holder *holder) {
            _holder = holder; // holder is now managed by intrusive_ptr
            //_holder->inc() ;
            init(holder->data);
        }
    };

    ostream& operator<<( ostream &s, const BSONObj &o );
    ostream& operator<<( ostream &s, const BSONElement &e );

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


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

}