some thoughts about cursors, nothing special yet

src/cursor.h

@@ -19,6 +19,9 @@
 #ifndef LMDBAL_CURSOR_H
 #define LMDBAL_CURSOR_H
 
+#include <string>
+
+#include "lmdb.h"
 #include "base.h"
 #include "storage.h"
 
@@ -28,18 +31,45 @@ template <class K, class V>
 class Cursor {
     friend class Storage<K, V>;
 private:
+    enum State {            /**<Cursor state:*/
+        closed,             /**<    - closed*/
+        openedPublic,       /**<    - opened with public transaction, all storages will be notified about it after it's done*/
+        openedPrivate       /**<    - opened with private transaction, only current storage will be notified when cursor is closed*/
+    };
+
     Cursor(Storage<K, V>* parent);
     ~Cursor();
 
 public:
-    void open();
+    void open() const;
-    void close();
+    void open(TransactionID txn) const;
+    void renew() const;
+    void renew(TransactionID txn) const;
+    void close() 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;
+    std::pair<K, V> current() const;
+
+    void first(std::pair<K, V>& out) const;
+    void last(std::pair<K, V>& out) const;
+    void next(std::pair<K, V>& out) const;
+    void prev(std::pair<K, V>& out) const;
+    void current(std::pair<K, V>& out) const;
 
 private:
-    void terminated();
+    void terminated() const;
 
 private:
     Storage<K, V>* storage;
+    mutable MDB_cursor* cursor;
+    mutable State state;
+
+    inline static const std::string openRecordMethodName = "Cursor::open";   /**<\brief member function name, just for exceptions*/
+    inline static const std::string closeRecordMethodName = "Cursor::close"; /**<\brief member function name, just for exceptions*/
+    inline static const std::string renewRecordMethodName = "Cursor::renew"; /**<\brief member function name, just for exceptions*/
 };
 
 };

src/cursor.hpp

@@ -23,19 +23,122 @@
 
 template<class K, class V>
 LMDBAL::Cursor<K, V>::Cursor(Storage<K, V>* parent):
-    storage(parent)
+    storage(parent),
+    cursor(nullptr),
+    state(closed)
 {
 
 }
 
 template<class K, class V>
 LMDBAL::Cursor<K, V>::~Cursor () {
-
+    close();
 }
 
 template<class K, class V>
-void LMDBAL::Cursor<K, V>::terminated () {
+void LMDBAL::Cursor<K, V>::terminated () const {
+    close();        //for now it's the same, but if I ever going to make writable cursor - here is where it's gonna be different
+}
 
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::open () const {
+    storage->ensureOpened(openRecordMethodName);
+    switch (state) {
+        case closed: {
+            TransactionID txn = storage->beginReadOnlyTransaction();
+            int result = mdb_cursor_open(txn, storage->dbi, &cursor);
+            if (result != MDB_SUCCESS)
+                storage->throwUnknown(result, txn);
+
+            storage->transactionStarted(txn, true);
+            state = openedPrivate;
+        } break;
+        default:
+            break;
+    }
+}
+
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::open (TransactionID txn) const {
+    storage->ensureOpened(openRecordMethodName);
+    switch (state) {
+        case closed: {
+            int result = mdb_cursor_open(txn, storage->dbi, &cursor);
+            if (result != MDB_SUCCESS)
+                storage->throwUnknown(result);
+
+            state = openedPublic;
+        } break;
+        default:
+            break;
+    }
+}
+
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::renew () const {
+    storage->ensureOpened(openRecordMethodName);
+    switch (state) {
+        case openedPrivate: {
+            TransactionID txn = mdb_cursor_txn(cursor);
+            storage->abortTransaction(txn);
+            storage->transactionAborted(txn);
+            [[fallthrough]];
+        }
+        case openedPublic: {
+            TransactionID txn = storage->beginReadOnlyTransaction();
+            int result = mdb_cursor_renew(txn, cursor);
+            if (result != MDB_SUCCESS)
+                storage->throwUnknown(result, txn);
+
+            storage->transactionStarted(txn, true);
+            state = openedPrivate;
+        } break;
+        default:
+            break;
+    }
+}
+
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::renew (TransactionID txn) const {
+    storage->ensureOpened(openRecordMethodName);
+    switch (state) {
+        case openedPrivate: {
+            TransactionID txn = mdb_cursor_txn(cursor);
+            storage->abortTransaction(txn);
+            storage->transactionAborted(txn);
+            [[fallthrough]];
+        }
+        case openedPublic: {
+            int result = mdb_cursor_renew(txn, cursor);
+            if (result != MDB_SUCCESS)
+                storage->throwUnknown(result);
+
+            state = openedPublic;
+        } break;
+        default:
+            break;
+    }
+}
+
+template<class K, class V>
+void LMDBAL::Cursor<K, V>::close () const {
+    switch (state) {
+        case openedPublic: {
+            mdb_cursor_close(cursor);
+
+            state = closed;
+        } break;
+        case openedPrivate: {
+            TransactionID txn = mdb_cursor_txn(cursor);
+            mdb_cursor_close(cursor);
+            storage->abortTransaction(txn);
+            storage->transactionAborted(txn);
+
+            state = closed;
+        } break;
+        default:
+            break;
+    }
 }
 
 #endif //LMDBAL_CURSOR_HPP

src/storage.h

@@ -91,9 +91,6 @@ protected:
     static std::string toString(const T& value);
 };
 
-// template <class K, class V>
-// class Cursor;
-
 template <class K, class V>
 class Storage : public iStorage {
     friend class Base;

src/storage.hpp

@@ -54,7 +54,10 @@ LMDBAL::Storage<K, V>::Storage(const std::string& _name, Base* parent):
  * \brief Destroys a storage
  */
 template<class K, class V>
-LMDBAL::Storage<K, V>::~Storage() {}
+LMDBAL::Storage<K, V>::~Storage() {
+    for (Cursor<K, V>* cursor : cursors)
+        delete cursor;
+}
 
 /**
  * \brief Adds a key-value record to the storage