dbclientcursor.h

// file dbclientcursor.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 <stack>
 
#include "mongo/client/dbclientinterface.h"
#include "mongo/client/export_macros.h"
#include "mongo/db/jsobj.h"
#include "mongo/db/json.h"
#include "mongo/util/net/message.h"
 
namespace mongo {
 
class DBClientCursorShim;
class DBClientCursorShimCursorID;
class DBClientCursorShimArray;
class DBClientCursorShimTransform;
 
class MONGO_CLIENT_API DBClientCursorInterface : boost::noncopyable {
public:
    virtual ~DBClientCursorInterface() {}
    virtual bool more() = 0;
    virtual BSONObj next() = 0;
    // TODO bring more of the DBClientCursor interface to here
protected:
    DBClientCursorInterface() {}
};
 
class MONGO_CLIENT_API DBClientCursor : public DBClientCursorInterface {
public:
    bool more();
 
    int objsLeftInBatch() const {
        _assertIfNull();
        return _putBack.size() + batch.nReturned - batch.pos;
    }
    bool moreInCurrentBatch() {
        return objsLeftInBatch() > 0;
    }
 
    BSONObj next();
 
    void putBack(const BSONObj& o) {
        _putBack.push(o.getOwned());
    }
 
    BSONObj nextSafe();
 
    void peek(std::vector<BSONObj>&, int atMost);
 
    // Peeks at first element, if exists
    BSONObj peekFirst();
 
    bool peekError(BSONObj* error = NULL);
 
    int itcount() {
        int c = 0;
        while (more()) {
            next();
            c++;
        }
        return c;
    }
 
    bool isDead() const {
        return cursorId == 0;
    }
 
    bool tailable() const {
        return (opts & QueryOption_CursorTailable) != 0;
    }
 
    bool hasResultFlag(int flag) {
        _assertIfNull();
        return (resultFlags & flag) != 0;
    }
 
    void setBatchSize(int newBatchSize) {
        batchSize = newBatchSize;
    }
 
    DBClientCursor(DBClientBase* client,
                   const std::string& _ns,
                   BSONObj _query,
                   int _nToReturn,
                   int _nToSkip,
                   const BSONObj* _fieldsToReturn,
                   int queryOptions,
                   int bs);
    DBClientCursor(DBClientBase* client,
                   const std::string& _ns,
                   long long _cursorId,
                   int _nToReturn,
                   int options,
                   int _batchSize);
 
    virtual ~DBClientCursor();
 
    long long getCursorId() const {
        return cursorId;
    }
 
    void decouple() {
        _ownCursor = false;
    }
 
    std::string originalHost() const {
        return _originalHost;
    }
 
    std::string getns() const {
        return ns;
    }
 
    Message* getMessage() {
        return batch.m.get();
    }
 
    bool initCommand();
 
    bool init();
 
    void initLazy(bool isRetry = false);
    bool initLazyFinish(bool& retry);
 
    class Batch : boost::noncopyable {
        friend class DBClientCursor;
        std::auto_ptr<Message> m;
        int nReturned;
        int pos;
        const char* data;
 
    public:
        Batch() : m(new Message()), nReturned(), pos(), data() {}
    };
 
    void kill();
 
private:
    friend class DBClientBase;
    friend class DBClientConnection;
    friend class DBClientCursorShimCursorID;
    friend class DBClientCursorShimArray;
    friend class DBClientCursorShimTransform;
    friend class DBClientWithCommands;
 
    int nextBatchSize();
    void _finishConsInit();
 
    BSONObj rawNext();
    bool rawMore();
 
    std::auto_ptr<DBClientCursorShim> shim;
 
    Batch batch;
    DBClientBase* _client;
    std::string _originalHost;
    std::string ns;
    BSONObj query;
    int nToReturn;
    int nToSkip;
    long long nReturned;
    const BSONObj* fieldsToReturn;
    int opts;
    int batchSize;
    std::stack<BSONObj> _putBack;
    int resultFlags;
    long long cursorId;
    bool _ownCursor;  // see decouple()
    std::string _scopedHost;
    std::string _lazyHost;
    bool wasError;
 
    void dataReceived() {
        bool retry;
        std::string lazyHost;
        dataReceived(retry, lazyHost);
    }
    void dataReceived(bool& retry, std::string& lazyHost);
    void requestMore();
    void exhaustReceiveMore();  // for exhaust
 
    // Don't call from a virtual function
    void _assertIfNull() const {
        uassert(13348, "connection died", this);
    }
 
    // non-copyable , non-assignable
    DBClientCursor(const DBClientCursor&);
    DBClientCursor& operator=(const DBClientCursor&);
 
    // init pieces
    void _assembleInit(Message& toSend);
};
 
class MONGO_CLIENT_API DBClientCursorBatchIterator {
public:
    DBClientCursorBatchIterator(DBClientCursor& c) : _c(c), _n() {}
    bool moreInCurrentBatch() {
        return _c.moreInCurrentBatch();
    }
    BSONObj nextSafe() {
        massert(13383, "BatchIterator empty", moreInCurrentBatch());
        ++_n;
        return _c.nextSafe();
    }
    int n() const {
        return _n;
    }
 
private:
    DBClientCursor& _c;
    int _n;
};
 
}  // namespace mongo