bsonobj.h

Go to the documentation of this file.

// @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 <set>
#include <list>
#include <vector>
#include "util/builder.h"
#include "stringdata.h"

namespace mongo {

    typedef set< BSONElement, BSONElementCmpWithoutField > BSONElementSet;

    class BSONObj {
    public:

        explicit BSONObj(const char *msgdata, bool ifree = false) {
            init(msgdata, ifree);
        }

        explicit BSONObj(const Record *r);

        BSONObj();

        ~BSONObj() { /*defensive:*/ _objdata = 0; }

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

        /* make sure the data buffer is under the control of this BSONObj and not a remote buffer */
        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;
        BSONElement getFieldDottedOrArray(const char *&name) const;

        BSONElement getField(const StringData& name) 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(); }

        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 woEqual(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); }

        bool hasElement(const char *name) const;

        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 woCompare( other ) == 0;
        }

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

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

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

    private:
        class Holder {
        public:
            Holder( const char *objdata ) :
                _objdata( objdata ) {
            }
            ~Holder() {
                free((void *)_objdata);
                _objdata = 0;
            }
        private:
            const char *_objdata;
        };

        const char *_objdata;
        boost::shared_ptr< Holder > _holder;

        void _assertInvalid() const;
        void init(const char *data, bool ifree) {
            if ( ifree )
                _holder.reset( new Holder( data ) );
            _objdata = data;
            if ( !isValid() )
                _assertInvalid();
        }
    };

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

}

---

mongodb
Author(s): Nate Koenig
autogenerated on Fri Jan 11 12:15:18 2013