cursor.hpp

/*
 * LMDB Abstraction Layer.
 * Copyright (C) 2023  Yury Gubich <blue@macaw.me>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "cursor.h"
#include <iostream>
 
static uint32_t idCounter = 0;
 
template<class K, class V>
LMDBAL::Cursor<K, V>::Cursor(Storage<K, V>* parent):
    storage(parent),
    cursor(nullptr),
    state(closed),
    id(++idCounter)
{
    storage->cursors[id] = this;
}
 
template<class K, class V>
LMDBAL::Cursor<K, V>::Cursor():
    storage(nullptr),
    cursor(nullptr),
    state(closed),
    id(0)
{}
 
template<class K, class V>
LMDBAL::Cursor<K, V>::Cursor(Cursor&& other):
    storage(other.storage),
    cursor(other.cursor),
    state(other.state),
    id(other.id)
{
    other.terminated();
    if (id != 0)
        storage->cursors[id] = this;
 
    other.freed();
}
 
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.freed();
        other.state = closed;
 
        storage->cursors[id] = this;
    }
 
    return *this;
}
 
template<class K, class V>
LMDBAL::Cursor<K, V>::~Cursor () {
    close();
 
    if (id != 0)
        storage->cursors.erase(id);
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::drop () {
    close();
 
    if (id != 0)
        storage->cursors.erase(id);
 
    freed();
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::dropped () {
    terminated();
    freed();
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::freed () {
    cursor = nullptr;
    storage = nullptr;
    id = 0;
}
 
template<class K, class V>
bool LMDBAL::Cursor<K, V>::empty () const {
    return id == 0;
}
 
template<class K, class V>
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
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::open () {
    if (empty())
        throw CursorEmpty(openCursorMethodName);
 
    storage->ensureOpened(openCursorMethodName);
    switch (state) {
        case closed: {
            TransactionID txn = storage->beginReadOnlyTransaction();
            int result = storage->_mdbCursorOpen(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>::open (const Transaction& transaction) {
    if (empty())
        throw CursorEmpty(openCursorMethodName);
 
    storage->ensureOpened(openCursorMethodName);
    TransactionID txn = storage->extractTransactionId(transaction, openCursorMethodName);
    switch (state) {
        case closed: {
            int result = storage->_mdbCursorOpen(txn, &cursor);
            if (result != MDB_SUCCESS)
                storage->throwUnknown(result);
 
            state = openedPublic;
        } break;
        default:
            break;
    }
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::renew () {
    if (empty())
        throw CursorEmpty(openCursorMethodName);
 
    storage->ensureOpened(renewCursorMethodName);
    switch (state) {
        case openedPrivate: {
            TransactionID txn = storage->_mdbCursorTxn(cursor);
            storage->abortTransaction(txn);
            storage->transactionAborted(txn);
            [[fallthrough]];
        }
        case openedPublic: {
            TransactionID txn = storage->beginReadOnlyTransaction();
            int result = storage->_mdbCursorRenew(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 (const Transaction& transaction) {
    if (empty())
        throw CursorEmpty(openCursorMethodName);
 
    storage->ensureOpened(renewCursorMethodName);
    TransactionID txn = storage->extractTransactionId(transaction, renewCursorMethodName);
    switch (state) {
        case openedPrivate: {
            TransactionID txn = storage->_mdbCursorTxn(cursor);
            storage->abortTransaction(txn);
            storage->transactionAborted(txn);
            [[fallthrough]];
        }
        case openedPublic: {
            int result = storage->_mdbCursorRenew(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 () {
    switch (state) {
        case openedPublic: {
            storage->_mdbCursorClose(cursor);
 
            state = closed;
        } break;
        case openedPrivate: {
            TransactionID txn = storage->_mdbCursorTxn(cursor);
            storage->_mdbCursorClose(cursor);
            storage->abortTransaction(txn);
            storage->transactionAborted(txn);
 
            state = closed;
        } break;
        default:
            break;
    }
}
 
template<class K, class V>
bool LMDBAL::Cursor<K, V>::opened () const {
    return state != closed;
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::first (K& key, V& value) {
    operateCursorRead(key, value, MDB_FIRST, firstMethodName, firstOperationName);
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::last (K& key, V& value) {
    operateCursorRead(key, value, MDB_LAST, lastMethodName, lastOperationName);
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::next (K& key, V& value) {
    operateCursorRead(key, value, MDB_NEXT, nextMethodName, nextOperationName);
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::prev (K& key, V& value) {
    operateCursorRead(key, value, MDB_PREV, prevMethodName, prevOperationName);
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::current (K& key, V& value) const {
    operateCursorRead(key, value, MDB_GET_CURRENT, currentMethodName, currentOperationName);
}
 
template<class K, class V>
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;
}
 
template<class K, class V>
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;
}
 
template<class K, class V>
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;
}
 
template<class K, class V>
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;
}
 
template<class K, class V>
std::pair<K, V> LMDBAL::Cursor<K, V>::current () const {
    std::pair<K, V> result;
    operateCursorRead(result.first, result.second, MDB_GET_CURRENT, currentMethodName, currentOperationName);
    return result;
}
 
template<class K, class V>
bool LMDBAL::Cursor<K, V>::set (const K& key) {
    if (state == closed)
        storage->throwCursorNotReady(setMethodName);
 
    MDB_val mdbKey = storage->keySerializer.setData(key);
    int result = storage->_mdbCursorSet(cursor, mdbKey);
    if (result == MDB_SUCCESS)
        return true;
    else if (result == MDB_NOTFOUND)
        return false;
 
    storage->throwUnknown(result);
    return false;   //unreachable, just to suppress the warning
}
 
template<class K, class V>
void LMDBAL::Cursor<K, V>::operateCursorRead(
    K& key,
    V& value,
    MDB_cursor_op operation,
    const std::string& methodName,
    const std::string& operationName
) const {
    if (state == closed)
        storage->throwCursorNotReady(methodName);
 
    MDB_val mdbKey, mdbValue;
    int result = storage->_mdbCursorGet(cursor, mdbKey, mdbValue, operation);
    if (result != MDB_SUCCESS)
        storage->throwNotFoundOrUnknown(result, operationName);
 
    storage->keySerializer.deserialize(mdbKey, key);
    storage->valueSerializer.deserialize(mdbValue, value);
 
    if (state == openedPrivate)
        storage->discoveredRecord(key, value);
    else
        storage->discoveredRecord(key, value, storage->_mdbCursorTxn(cursor));
}