First attempt to make RAII cursors, no tests yet

src/cursor.h

@@ -38,37 +38,49 @@ private:
         openedPrivate       /**<    - opened with private transaction, only current storage will be notified when cursor is closed*/
     };
 
+public:
+    Cursor();
     Cursor(Storage<K, V>* parent);
+    Cursor(const Cursor& other) = delete;
+    Cursor(Cursor&& other);
     ~Cursor();
 
-public:
-    void open() const;
-    void open(const Transaction& transaction) const;
-    void renew() const;
-    void renew(const Transaction& transaction) const;
-    void close() const;
+    Cursor& operator = (const Cursor& other) = delete;
+    Cursor& operator = (Cursor&& other);
+
+    void open();
+    void open(const Transaction& transaction);
+    void renew();
+    void renew(const Transaction& transaction);
+    void close();
     bool opened() const;
+    bool empty() const;
 
-    std::pair<K, V> first() const;
-    std::pair<K, V> last() const;
-    std::pair<K, V> next() const;
-    std::pair<K, V> prev() const;
+    void drop();
+
+    std::pair<K, V> first();
+    std::pair<K, V> last();
+    std::pair<K, V> next();
+    std::pair<K, V> prev();
     std::pair<K, V> current() const;
+    bool set(const K& target);
 
-    void first(K& key, V& value) const;
-    void last(K& key, V& value) const;
-    void next(K& key, V& value) const;
-    void prev(K& key, V& value) const;
+    void first(K& key, V& value);
+    void last(K& key, V& value);
+    void next(K& key, V& value);
+    void prev(K& key, V& value);
     void current(K& key, V& value) const;
 
 private:
-    void terminated() const;
+    void dropped();
+    void terminated();
     void operateCursorRead(K& key, V& value, MDB_cursor_op operation, const std::string& methodName, const std::string& operationName) const;
 
 private:
     Storage<K, V>* storage;
-    mutable MDB_cursor* cursor;
-    mutable State state;
+    MDB_cursor* cursor;
+    State state;
+    uint32_t id;
 
     inline static const std::string openCursorMethodName = "Cursor::open";      /**<\brief member function name, just for exceptions*/
     inline static const std::string closeCursorMethodName = "Cursor::close";    /**<\brief member function name, just for exceptions*/

src/cursor.hpp

@@ -41,6 +41,8 @@
  * You are not supposed to instantiate or destory instances of this class yourself!
  */
 
+static uint32_t idCounter = 0;
+
 /**
  * \brief Creates a cursor
  *
@@ -50,9 +52,74 @@ template<class K, class V>
 LMDBAL::Cursor<K, V>::Cursor(Storage<K, V>* parent):
     storage(parent),
     cursor(nullptr),
-    state(closed)
+    state(closed),
+    id(++idCounter)
+{
+    storage->cursors[id] = this;
+}
+
+/**
+ * \brief Creates an empty cursor.
+ *
+ * It's not usable, but can exist just to be a target of moves
+ */
+template<class K, class V>
+LMDBAL::Cursor<K, V>::Cursor():
+    storage(nullptr),
+    cursor(nullptr),
+    state(closed),
+    id(0)
 {}
 
+/**
+ * \brief Moves from another cursor
+ */
+template<class K, class V>
+LMDBAL::Cursor<K, V>::Cursor(Cursor&& other):
+    storage(other.storage),
+    cursor(other.cursor),
+    state(other.state),
+    id(other.id)
+{
+    if (id != 0)
+        storage->cursors[id] = this;
+
+    other.cursor = nullptr;
+    other.storage = nullptr;
+    other.id = 0;
+    other.state = closed;
+}
+
+/**
+ * \brief A private function that turns cursor into an empty one
+ *
+ * This function is called from LMDBAL::Storage, when it gets destroyed, but still has some valid.
+ * Those cursors will become empty, and can't be used anymore
+ */
+template<class K, class V>
+LMDBAL::Cursor<K, V>& LMDBAL::Cursor<K, V>::operator = (Cursor&& other) {
+    terminated();
+
+    if (id != 0)
+        storage->cursors.erase(id);
+
+    storage = other.storage;
+    cursor = other.cursor;
+    state = other.state;
+    id = other.id;
+
+    if (id != 0) {
+        other.cursor = nullptr;
+        other.storage = nullptr;
+        other.id = 0;
+        other.state = closed;
+
+        storage->cursors[id] = this;
+    }
+
+    return *this;
+}
+
 /**
  * \brief Destroys a cursor
  *
@@ -61,13 +128,58 @@ LMDBAL::Cursor<K, V>::Cursor(Storage<K, V>* parent):
 template<class K, class V>
 LMDBAL::Cursor<K, V>::~Cursor () {
     close();
+
+    if (id != 0)
+        storage->cursors.erase(id);
+}
+
+/**
+ * \brief Turns cursor into an empty one, releasing resources
+ *
+ * This function is called from LMDBAL::Storage, when it gets destroyed, but still has some valid.
+ * Those cursors will become empty, and can't be used anymore
+ */
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::drop () {
+    close();
+
+    if (id != 0)
+        storage->cursors.erase(id);
+
+    cursor = nullptr;
+    storage = nullptr;
+    id = 0;
+}
+
+/**
+ * \brief A private method that turns cursor into an empty one
+ *
+ * This function is called from LMDBAL::Storage, when it gets destroyed, but still has some valid.
+ * Those cursors will become empty, and can't be used anymore
+ */
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::dropped () {
+    terminated();
+    cursor = nullptr;
+    storage = nullptr;
+    id = 0;
+}
+
+/**
+ * \brief Returns true if the cursor is empty
+ *
+ * Empty cursors can't be used, they can be only targets of move operations
+ */
+template<class K, class V>
+bool LMDBAL::Cursor<K, V>::empty () const {
+    return id == 0;
 }
 
 /**
  * \brief A private function the storage owning this cursor will call to inform this cursor that the thansaction needs to be aborted
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::terminated () const {
+void LMDBAL::Cursor<K, V>::terminated () {
     close();        //for now it's the same, but if I ever going to make writable cursor - here is where it's gonna be different
 }
 
@@ -80,11 +192,15 @@ void LMDBAL::Cursor<K, V>::terminated () const {
  * This function should be called when the LMDBAL::Storage is already opened and before any query with this cursor!
  * It will do nothing to a cursor that was already opened (no matter what way).
  *
- * \exception LMDBAL::Closed   thrown if you try to open the cursor on a closed database
- * \exception LMDBAL::Unknown  thrown if there was a problem opening the cursor by the lmdb, or to begin a transaction
+ * \exception LMDBAL::Closed        thrown if you try to open the cursor on a closed database
+ * \exception LMDBAL::Unknown       thrown if there was a problem opening the cursor by the lmdb, or to begin a transaction
+ * \exception LMDBAL::CursorEmpty   thrown if the cursor was empty
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::open () const {
+void LMDBAL::Cursor<K, V>::open () {
+    if (empty())
+        throw CursorEmpty(openCursorMethodName);
+
     storage->ensureOpened(openCursorMethodName);
     switch (state) {
         case closed: {
@@ -115,9 +231,13 @@ void LMDBAL::Cursor<K, V>::open () const {
  * \exception LMDBAL::Closed                thrown if you try to open the cursor on a closed database
  * \exception LMDBAL::Unknown               thrown if there was a problem opening the cursor by the lmdb
  * \exception LMDBAL::TransactionTerminated thrown if the passed transaction not active, any action with it's inner ID is an error
+ * \exception LMDBAL::CursorEmpty           thrown if the cursor was empty
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::open (const Transaction& transaction) const {
+void LMDBAL::Cursor<K, V>::open (const Transaction& transaction) {
+    if (empty())
+        throw CursorEmpty(openCursorMethodName);
+
     storage->ensureOpened(openCursorMethodName);
     TransactionID txn = storage->extractTransactionId(transaction, openCursorMethodName);
     switch (state) {
@@ -146,11 +266,15 @@ void LMDBAL::Cursor<K, V>::open (const Transaction& transaction) const {
  *
  * This function does nothing if the cursor is closed
  *
- * \exception LMDBAL::Closed   thrown if you try to renew the cursor on a closed database
- * \exception LMDBAL::Unknown  thrown if there was a problem beginning new transaction or if there was a problem renewing the cursor by lmdb
+ * \exception LMDBAL::Closed        thrown if you try to renew the cursor on a closed database
+ * \exception LMDBAL::Unknown       thrown if there was a problem beginning new transaction or if there was a problem renewing the cursor by lmdb
+ * \exception LMDBAL::CursorEmpty   thrown if the cursor was empty
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::renew () const {
+void LMDBAL::Cursor<K, V>::renew () {
+    if (empty())
+        throw CursorEmpty(openCursorMethodName);
+
     storage->ensureOpened(renewCursorMethodName);
     switch (state) {
         case openedPrivate: {
@@ -191,9 +315,13 @@ void LMDBAL::Cursor<K, V>::renew () const {
  * \exception LMDBAL::Closed                thrown if you try to renew the cursor on a closed database
  * \exception LMDBAL::Unknown               thrown if there was a problem renewing the cursor by lmdb
  * \exception LMDBAL::TransactionTerminated thrown if the passed transaction not active, any action with it's inner ID is an error
+ * \exception LMDBAL::CursorEmpty           thrown if the cursor was empty
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::renew (const Transaction& transaction) const {
+void LMDBAL::Cursor<K, V>::renew (const Transaction& transaction) {
+    if (empty())
+        throw CursorEmpty(openCursorMethodName);
+
     storage->ensureOpened(renewCursorMethodName);
     TransactionID txn = storage->extractTransactionId(transaction, renewCursorMethodName);
     switch (state) {
@@ -226,7 +354,7 @@ void LMDBAL::Cursor<K, V>::renew (const Transaction& transaction) const {
  * This function does nothing on a closed cursor.
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::close () const {
+void LMDBAL::Cursor<K, V>::close () {
     switch (state) {
         case openedPublic: {
             mdb_cursor_close(cursor);
@@ -267,7 +395,7 @@ bool LMDBAL::Cursor<K, V>::opened () const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::first (K& key, V& value) const {
+void LMDBAL::Cursor<K, V>::first (K& key, V& value) {
     operateCursorRead(key, value, MDB_FIRST, firstMethodName, firstOperationName);
 }
 
@@ -284,7 +412,7 @@ void LMDBAL::Cursor<K, V>::first (K& key, V& value) const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::last (K& key, V& value) const {
+void LMDBAL::Cursor<K, V>::last (K& key, V& value) {
     operateCursorRead(key, value, MDB_LAST, lastMethodName, lastOperationName);
 }
 
@@ -307,7 +435,7 @@ void LMDBAL::Cursor<K, V>::last (K& key, V& value) const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::next (K& key, V& value) const {
+void LMDBAL::Cursor<K, V>::next (K& key, V& value) {
     operateCursorRead(key, value, MDB_NEXT, nextMethodName, nextOperationName);
 }
 
@@ -330,7 +458,7 @@ void LMDBAL::Cursor<K, V>::next (K& key, V& value) const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::prev (K& key, V& value) const {
+void LMDBAL::Cursor<K, V>::prev (K& key, V& value) {
     operateCursorRead(key, value, MDB_PREV, prevMethodName, prevOperationName);
 }
 
@@ -349,7 +477,7 @@ void LMDBAL::Cursor<K, V>::prev (K& key, V& value) const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::current (K& key, V& value) const {
+void LMDBAL::Cursor<K, V>::current (K& key, V& value) const  {
     operateCursorRead(key, value, MDB_GET_CURRENT, currentMethodName, currentOperationName);
 }
 
@@ -365,7 +493,7 @@ void LMDBAL::Cursor<K, V>::current (K& key, V& value) const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-std::pair<K, V> LMDBAL::Cursor<K, V>::first () const {
+std::pair<K, V> LMDBAL::Cursor<K, V>::first () {
     std::pair<K, V> result;
     operateCursorRead(result.first, result.second, MDB_FIRST, firstMethodName, firstOperationName);
     return result;
@@ -383,7 +511,7 @@ std::pair<K, V> LMDBAL::Cursor<K, V>::first () const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-std::pair<K, V> LMDBAL::Cursor<K, V>::last () const {
+std::pair<K, V> LMDBAL::Cursor<K, V>::last () {
     std::pair<K, V> result;
     operateCursorRead(result.first, result.second, MDB_LAST, lastMethodName, lastOperationName);
     return result;
@@ -407,7 +535,7 @@ std::pair<K, V> LMDBAL::Cursor<K, V>::last () const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-std::pair<K, V> LMDBAL::Cursor<K, V>::next () const {
+std::pair<K, V> LMDBAL::Cursor<K, V>::next () {
     std::pair<K, V> result;
     operateCursorRead(result.first, result.second, MDB_NEXT, nextMethodName, nextOperationName);
     return result;
@@ -431,7 +559,7 @@ std::pair<K, V> LMDBAL::Cursor<K, V>::next () const {
  * \exception LMDBAL::Unknown          thrown if there was some unexpected problem with lmdb
  */
 template<class K, class V>
-std::pair<K, V> LMDBAL::Cursor<K, V>::prev () const {
+std::pair<K, V> LMDBAL::Cursor<K, V>::prev () {
     std::pair<K, V> result;
     operateCursorRead(result.first, result.second, MDB_PREV, prevMethodName, prevOperationName);
     return result;

src/exceptions.cpp

@@ -72,6 +72,14 @@ std::string LMDBAL::CursorNotReady::getMessage() const {
     return msg;
 }
 
+LMDBAL::CursorEmpty::CursorEmpty(const std::string & operation):
+    Exception(),
+    operation(operation) {}
+
+std::string LMDBAL::CursorEmpty::getMessage() const {
+    return "An attempt to perform an operation \"" + operation + "\" on an empty cursor";
+}
+
 LMDBAL::Opened::Opened(const std::string& p_dbName, const std::string& p_action):
     Exception(),
     dbName(p_dbName),

src/exceptions.h

@@ -97,6 +97,23 @@ private:
     std::string tableName;
 };
 
+/**
+ * \brief Thrown if an empty cursor was somehow operated
+ */
+class CursorEmpty : public Exception {
+public:
+    /**
+     * \brief Creates exception
+     *
+     * \param operation - text name of the method that was called on an empty cursor
+     */
+    CursorEmpty(const std::string& operation);
+
+    std::string getMessage() const;
+private:
+    std::string operation;
+};
+
 /**
  * \brief Thrown if something in the database was called on opened state and it is not supported
  */

src/storage.h

@@ -29,6 +29,8 @@
 
 class BaseTest;
 class DuplicatesTest;
+class CacheCursorTest;
+class StorageCursorTest;
 
 namespace LMDBAL {
 
@@ -113,6 +115,8 @@ template <class K, class V>
 class Storage : public iStorage {
     friend class ::BaseTest;
     friend class ::DuplicatesTest;
+    friend class ::CacheCursorTest;
+    friend class ::StorageCursorTest;
     friend class Base;
     friend class Cursor<K, V>;
 protected:
@@ -160,13 +164,13 @@ public:
     virtual uint32_t addRecords(const std::map<K, V>& data, bool overwrite = false);
     virtual uint32_t addRecords(const std::map<K, V>& data, const WriteTransaction& txn, bool overwrite = false);
 
-    Cursor<K, V>* createCursor();
-    void destroyCursor(Cursor<K, V>* cursor);
+    Cursor<K, V> createCursor();
+    void destroyCursor(Cursor<K, V>& cursor);
 
 protected:
     mutable Serializer<K> keySerializer;        /**<\brief internal object that would serialize and deserialize keys*/
     mutable Serializer<V> valueSerializer;      /**<\brief internal object that would serialize and deserialize values*/
-    std::set<Cursor<K, V>*> cursors;            /**<\brief a set of cursors that has been created under this storage*/
+    std::map<uint32_t, Cursor<K, V>*> cursors;  /**<\brief a set of cursors that has been created under this storage*/
 
     int open(MDB_txn* transaction) override;
     void close() override;

src/storage.hpp

@@ -58,8 +58,8 @@ LMDBAL::Storage<K, V>::Storage(Base* parent, const std::string& name, bool dupli
  */
 template<class K, class V>
 LMDBAL::Storage<K, V>::~Storage() {
-    for (Cursor<K, V>* cursor : cursors)
-        delete cursor;
+    for (const std::pair<const uint32_t, Cursor<K, V>*>& pair : cursors)
+        pair.second->dropped();
 }
 
 /**
@@ -1013,8 +1013,8 @@ int LMDBAL::Storage<K, V>::open(MDB_txn* transaction) {
  */
 template<class K, class V>
 void LMDBAL::Storage<K, V>::close() {
-    for (Cursor<K, V>* cursor : cursors)
-        cursor->terminated();
+    for (const std::pair<const uint32_t, Cursor<K, V>*>& pair : cursors)
+        pair.second->terminated();
 
     iStorage::close();
 }
@@ -1025,11 +1025,8 @@ void LMDBAL::Storage<K, V>::close() {
  * \returns LMDBAL::Cursor for this storage and returs you a pointer to a created cursor
  */
 template<class K, class V>
-LMDBAL::Cursor<K, V>* LMDBAL::Storage<K, V>::createCursor() {
-    Cursor<K, V>* cursor = new Cursor<K, V>(this);
-    cursors.insert(cursor);
-
-    return cursor;
+LMDBAL::Cursor<K, V> LMDBAL::Storage<K, V>::createCursor() {
+    return Cursor<K, V>(this);
 }
 
 /**
@@ -1056,25 +1053,6 @@ uint32_t LMDBAL::Storage<K, V>::flags() const {
     return result;
 }
 
-/**
- * \brief Destroys cursor
- *
- * This a normal way to discard a cursor you don't need anymore
- *
- * \param[in] cursor    a pointer to a cursor you want to destroy
- *
- * \exception LMDBAL::Unknown  thrown if you try to destroy something that this storage didn't create
- */
-template<class K, class V>
-void LMDBAL::Storage<K, V>::destroyCursor(Cursor<K, V>* cursor) {
-    typename std::set<Cursor<K, V>*>::const_iterator itr = cursors.find(cursor);
-    if (itr == cursors.end())
-        throwUnknown("An attempt to destroy a cursor the storage doesn't own");
-
-    cursors.erase(itr);
-    delete cursor;
-}
-
 /**
  * \brief A private virtual method that cursor calls when he reads a record, does nothing here but populates the LMDBAL::Cache
  *