C++ BSONObj::getIntField方法代码示例

int paraseUserStockCfg(BSONObj obj,std::vector<user_stock_cfg>& uscarray)
{
	std::string uid = obj.getStringField("Uid");
	std::vector<BSONElement> elements = obj["stocks"].Array();
	std::vector<BSONElement>::iterator it = elements.begin();
	int count = 0;
	for(; it != elements.end(); ++it)
	{
		BSONObj stock = it->Obj();
		user_stock_cfg usc;
		usc.uid = uid;
		usc.stock = stock.getStringField("stock");
		usc.bulletin = stock.getIntField("bulletin");
		if(stock.getField("max_price").ok())
			usc.max_price = stock.getField("max_price").Double();
		else
			usc.max_price = -0.111;
		
		if(stock.getField("min_price").ok())
			usc.min_price = stock.getField("min_price").Double();
		else
			usc.min_price = -0.111;
	
		usc.run = stock.getIntField("run");
		uscarray.push_back(usc);
		count++;
	}
	return count ;
}

/**********************************************************
 *see readFromDB in FileRec, similar structure
 * 
***********************************************************/
void VersionRec::readFromDB(mongo::DBClientConnection& conn, string versionID) {

    auto_ptr<mongo::DBClientCursor> cursor =
            conn.query("fileRecords.FileVersion", MONGO_QUERY("_id" << mongo::OID(versionID)));

    if (cursor->more()) {
        //convert to VersionRec
        BSONObj record = cursor->next();
        this->versionid = versionID;
        this->tmpname = record.getStringField("Tempname");
        this->filehash = record.getStringField("filehash");
        this->length = record.getIntField("length");
        this->modifytime.tv_nsec = record.getField("Mtnsec").numberLong();
        this->modifytime.tv_sec = record.getField("mtsec").numberLong();
        this->versionnumber = record.getIntField("Version");

        //similar to the comments collection in readfromDB in FileRec
        vector<BSONElement> hashes(record.getField("Blktable").Array());
        for (vector<BSONElement>::iterator it = hashes.begin(); it != hashes.end(); ++it) {

            BSONObj blockdata = it->Obj();
            BSONElement blocknum = blockdata.getField("Blknum");
            BSONElement blockhash = blockdata.getField("hash");

            VersionDiffBlock tmp;
            tmp.blockNo = blocknum.Int();
            tmp.blockHash = blockhash.String();
            changesAppend(tmp);
        }
    }
    else{
        cout << "could not find version " << versionID << endl;
    }
}

void parseMobileToken(BSONObj obj,mobile_apptypes& app)
{
	app.token = obj.getStringField("Token");
	if(obj.getField("incrementID").ok())
		app.incrementID = obj.getField("incrementID").Long();
	else
		app.incrementID = -1;
	app.osversion = obj.getStringField("osversion");
	app.comment = obj.getStringField("comment");

	std::vector<BSONElement> elements = obj["apptypes"].Array();
	std::vector<BSONElement>::iterator it = elements.begin();

	for(; it != elements.end(); ++it)
	{
		BSONObj appobj = it->Obj();
		apptypeinfo appinfo;
		appinfo.apptype = appobj.getIntField("apptype");		
		if(appobj.getField("flag").ok())
			appinfo.flag = appobj.getIntField("flag");
		else 
			appinfo.flag = 0;
		appinfo.lastuid = appobj.getStringField("lastuid");
		if(appobj.getField("lasttime").ok())
			appinfo.lasttime = appobj.getField("lasttime").Long();
		else
			appinfo.lasttime = 0;
		appinfo.appversion = appobj.getStringField("appversion");
		app.apptypes.push_back(appinfo);
	}
}

/**********************************************************
 *reads from db and converts bson to FileRec object
 * 
***********************************************************/
void FileRec::readFromDB(mongo::DBClientConnection& conn, string filename) {

    boost::filesystem::path p(filename); //get filename from path
    string file(p.filename().c_str());
    auto_ptr<mongo::DBClientCursor> cursor = conn.query("fileRecords.Filerec", MONGO_QUERY("filename" << file));

    if (cursor->more()) {

        BSONObj record = cursor->next();
        //get data from db and store in the FileRec
        this->filename = record.getStringField("filename");
        this->tempname = record.getStringField("Tempname");
        this->recentHash = record.getStringField("curhash");
        this->origHash = record.getStringField("ovhash");
        this->length = record.getIntField("length");
        this->versionCount = record.getIntField("nversions");
        this->modifytime.tv_nsec = record.getField("Mtnsec").numberLong();
        this->modifytime.tv_sec = record.getField("mtsec").numberLong();
        this->refNum = record.getIntField("currentversion");

        vector<BSONElement> hashes(record.getField("FileBlkHashes").Array());
        for (vector<BSONElement>::iterator it = hashes.begin(); it != hashes.end(); ++it) {
            appendBlock((*it).String());
        }

        //comments is an array of objects so it takes a bit of nesting to convert
        vector<BSONElement> array = record["comments"].Array(); //convert to array
        for (vector<BSONElement>::iterator ar = array.begin(); ar != array.end(); ++ar) {
            BSONObj commentdata = ar->Obj(); //store object at array[x] into BSONObj
            BSONElement version = commentdata.getField("version"); //convert
            BSONElement commentdb = commentdata.getField("comment");

            comment data;
            data.comment = commentdb.String();
            data.version = version.Int();
            appendComment(data);
        }


        if (record.hasElement("versionrec")) { //again an array of objects
            vector<BSONElement> array = record["versionrec"].Array();
            for (vector<BSONElement>::iterator it = array.begin(); it != array.end(); ++it) {

                BSONObj versionRecord = it->Obj();
                BSONElement id = versionRecord.getField("id");
                appendVersion(id.String());
            }
        } 
    }
}

        /**
         * @param args - [ name, byte index ]
         * In this initial implementation, all bits in the specified byte are flipped.
         */
        BSONObj fuzzFile(const BSONObj& args, void* data) {
            uassert( 13619, "fuzzFile takes 2 arguments", args.nFields() == 2 );
            scoped_ptr< File > f( new File() );
            f->open( args.getStringField( "0" ) );
            uassert( 13620, "couldn't open file to fuzz", !f->bad() && f->is_open() );

            char c;
            f->read( args.getIntField( "1" ), &c, 1 );
            c = ~c;
            f->write( args.getIntField( "1" ), &c, 1 );

            return undefinedReturn;
            // f close is implicit
        }

 virtual bool run(const char *ns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool fromRepl) {
     string fromhost = cmdObj.getStringField("from");
     if ( fromhost.empty() ) {
         errmsg = "missing from spec";
         return false;
     }
     string collection = cmdObj.getStringField("cloneCollection");
     if ( collection.empty() ) {
         errmsg = "missing cloneCollection spec";
         return false;
     }
     BSONObj query = cmdObj.getObjectField("query");
     if ( query.isEmpty() )
         query = BSONObj();
     BSONElement copyIndexesSpec = cmdObj.getField("copyindexes");
     bool copyIndexes = copyIndexesSpec.isBoolean() ? copyIndexesSpec.boolean() : true;
     // Will not be used if doesn't exist.
     int logSizeMb = cmdObj.getIntField( "logSizeMb" );
     
     /* replication note: we must logOp() not the command, but the cloned data -- if the slave
      were to clone it would get a different point-in-time and not match.
      */
     setClient( collection.c_str() );
     
     log() << "cloneCollection.  db:" << ns << " collection:" << collection << " from: " << fromhost << " query: " << query << " logSizeMb: " << logSizeMb << ( copyIndexes ? "" : ", not copying indexes" ) << endl;
     
     Cloner c;
     long long cursorId;
     if ( !c.startCloneCollection( fromhost.c_str(), collection.c_str(), query, errmsg, !fromRepl, copyIndexes, logSizeMb, cursorId ) )
         return false;
     return c.finishCloneCollection( fromhost.c_str(), collection.c_str(), query, cursorId, errmsg);
 }

bool CCentralizeZbxEventProcessor::ExecuteEarlyProcess(BSONObj boRecord)
{
	auto_ptr<DBClientCursor> ptrTriggerDataCursor;
	BSONObj boTriggerRecord;
	int iPriority;
	iPriority = 0;
	Query queryCondition = QUERY("triggerid" << boRecord["triggerid"] << "zabbix_server_id" << boRecord["zabbix_server_id"]);
	m_pTriggerLogController->Find(ptrTriggerDataCursor, queryCondition);
	if (ptrTriggerDataCursor->more())
	{
		boTriggerRecord = ptrTriggerDataCursor->nextSafe();
	}

	/*-- Check Trigger Info --*/
	if (boTriggerRecord.isEmpty())
	{
		return false;
	}
	iPriority = boTriggerRecord.hasField("priority") ? boTriggerRecord.getIntField("priority") : 0;
	if (5 != iPriority)
	{
		return false;
	}
	return true;
}

        virtual bool run(OperationContext* txn, const string& dbname , BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool) {
            string coll = cmdObj[ "captrunc" ].valuestrsafe();
            uassert( 13416, "captrunc must specify a collection", !coll.empty() );
            NamespaceString nss( dbname, coll );
            int n = cmdObj.getIntField( "n" );
            bool inc = cmdObj.getBoolField( "inc" ); // inclusive range?

            Client::WriteContext ctx(txn,  nss.ns() );
            Collection* collection = ctx.getCollection();
            massert( 13417, "captrunc collection not found or empty", collection);

            RecordId end;
            {
                boost::scoped_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(txn,
                                                                                     nss.ns(),
                                                                                     collection,
                                                                                     InternalPlanner::BACKWARD));
                // We remove 'n' elements so the start is one past that
                for( int i = 0; i < n + 1; ++i ) {
                    PlanExecutor::ExecState state = exec->getNext(NULL, &end);
                    massert( 13418, "captrunc invalid n", PlanExecutor::ADVANCED == state);
                }
            }
            WriteUnitOfWork wuow(txn);
            collection->temp_cappedTruncateAfter( txn, end, inc );
            wuow.commit();
            return true;
        }

std::vector<post> StorageEngine::getposts(int number) {
    std::vector<post> posts;
    collection = "posts";
    update_namespace();
    //if it's empty, return nothing.
    try {
        if(con.count(namespacestr) == 0)
            return posts;
        Query q("{ }");
        auto_ptr<DBClientCursor> cursor = con.query(namespacestr,q.sort("timestamp",-1));
        while(cursor->more()) {
            BSONObj record = cursor->next();
            post newpost;
            newpost.title = record.getStringField("title");
            newpost.body = record.getStringField("body");
            newpost.timestamp = record.getIntField("timestamp");
            newpost.oid = getoid(record);
            posts.push_back(newpost);
        }
    } catch( DBException &e ) {
        cout << "caught " << e.what() << endl;
        exit(0);
    }
    

    return posts;
}

    virtual bool run(OperationContext* opCtx,
                     const string& dbname,
                     const BSONObj& cmdObj,
                     BSONObjBuilder& result) {
        const NamespaceString fullNs = CommandHelpers::parseNsCollectionRequired(dbname, cmdObj);
        if (!fullNs.isValid()) {
            return CommandHelpers::appendCommandStatus(
                result,
                {ErrorCodes::InvalidNamespace,
                 str::stream() << "collection name " << fullNs.ns() << " is not valid"});
        }

        int n = cmdObj.getIntField("n");
        bool inc = cmdObj.getBoolField("inc");  // inclusive range?

        if (n <= 0) {
            return CommandHelpers::appendCommandStatus(
                result, {ErrorCodes::BadValue, "n must be a positive integer"});
        }

        // Lock the database in mode IX and lock the collection exclusively.
        AutoGetCollection autoColl(opCtx, fullNs, MODE_IX, MODE_X);
        Collection* collection = autoColl.getCollection();
        if (!collection) {
            return CommandHelpers::appendCommandStatus(
                result,
                {ErrorCodes::NamespaceNotFound,
                 str::stream() << "collection " << fullNs.ns() << " does not exist"});
        }

        if (!collection->isCapped()) {
            return CommandHelpers::appendCommandStatus(
                result, {ErrorCodes::IllegalOperation, "collection must be capped"});
        }

        RecordId end;
        {
            // Scan backwards through the collection to find the document to start truncating from.
            // We will remove 'n' documents, so start truncating from the (n + 1)th document to the
            // end.
            auto exec = InternalPlanner::collectionScan(
                opCtx, fullNs.ns(), collection, PlanExecutor::NO_YIELD, InternalPlanner::BACKWARD);

            for (int i = 0; i < n + 1; ++i) {
                PlanExecutor::ExecState state = exec->getNext(nullptr, &end);
                if (PlanExecutor::ADVANCED != state) {
                    return CommandHelpers::appendCommandStatus(
                        result,
                        {ErrorCodes::IllegalOperation,
                         str::stream() << "invalid n, collection contains fewer than " << n
                                       << " documents"});
                }
            }
        }

        collection->cappedTruncateAfter(opCtx, end, inc);

        return true;
    }

TEST(QueryTest, Sort) {
    Query q;
    q.sort(BSON("a" << 1));
    ASSERT_TRUE(q.isComplex());
    BSONObj sort = q.getSort();
    ASSERT_TRUE(sort.hasField("a"));
    ASSERT_EQUALS(sort.getIntField("a"), 1);
}

 unsigned long long DBClientWithCommands::count(const string &_ns, BSONObj query) { 
     NamespaceString ns(_ns);
     BSONObj cmd = BSON( "count" << ns.coll << "query" << query );
     BSONObj res;
     if( !runCommand(ns.db.c_str(), cmd, res) )
         uasserted(string("count fails:") + res.toString());
     return res.getIntField("n");
 }

    /**
     * SERVER-13001 - mixed sharded cluster could return nModified
     * (servers >= 2.6) or not (servers <= 2.4). If any call does
     * not return nModified we cannot report a valid final count.
     */
    void WriteResult::_setModified(const BSONObj& result) {
        int nModified = result.getIntField("nModified");

        if (_hasModifiedCount && nModified >= 0)
            _nModified += nModified;
        else
            _hasModifiedCount = false;
    }

// static
std::string WorkingSetCommon::toStatusString(const BSONObj& obj) {
    if (!isValidStatusMemberObject(obj)) {
        Status unknownStatus(ErrorCodes::UnknownError, "no details available");
        return unknownStatus.toString();
    }
    Status status(ErrorCodes::fromInt(obj.getIntField("code")), obj.getStringField("errmsg"));
    return status.toString();
}

 enum QueryOptions DBClientWithCommands::availableOptions() {
     if ( !_haveCachedAvailableOptions ) {
         BSONObj ret;
         if ( runCommand( "admin", BSON( "availablequeryoptions" << 1 ), ret ) ) {
             _cachedAvailableOptions = ( enum QueryOptions )( ret.getIntField( "options" ) );
         }
         _haveCachedAvailableOptions = true;
     }
     return _cachedAvailableOptions;
 }