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>


template<class K, class V>
LMDBAL::Cursor<K, V>::Cursor(Storage<K, V>* parent):
    CursorCommon(parent)
{
    parent->cursors[id] = this;
}

template<class K, class V>
LMDBAL::Cursor<K, V>::Cursor():
    CursorCommon()
{}

template<class K, class V>
LMDBAL::Cursor<K, V>::Cursor(Cursor&& other):
    CursorCommon(std::move(other))
{
    if (!empty())
        static_cast<Storage<K, V>*>(storage)->cursors[id] = this;
}

template<class K, class V>
LMDBAL::Cursor<K, V>& LMDBAL::Cursor<K, V>::operator = (Cursor&& other) {
    if (!empty() && other.empty())
        static_cast<Storage<K, V>*>(storage)->cursors.erase(id);
 
    CursorCommon::operator=(std::move(other));
 
    if (!empty())
        static_cast<Storage<K, V>*>(storage)->cursors[id] = this;
 
    return *this;
}

namespace LMDBAL {
template<class K, class V>
Cursor<K, V>::~Cursor() {
    if (id != 0) {
        static_cast<Storage<K, V>*>(storage)->cursors.erase(id);
    }
}
}

template<class K, class V>
void LMDBAL::Cursor<K, V>::drop () {
    close();
 
    if (id != 0)
        static_cast<Storage<K, V>*>(storage)->cursors.erase(id);
 
    reset();
}

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)
        static_cast<Storage<K, V>*>(storage)->throwCursorNotReady(setMethodName);
 
    MDB_val mdbKey = static_cast<Storage<K, V>*>(storage)->keySerializer.setData(key);
    int result = static_cast<Storage<K, V>*>(storage)->_mdbCursorSet(handle, mdbKey);
    if (result == MDB_SUCCESS)
        return true;
    else if (result == MDB_NOTFOUND)
        return false;
 
    static_cast<Storage<K, V>*>(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,
    std::string_view methodName,
    std::string_view operationName
) const {
    if (state == closed)
        static_cast<Storage<K, V>*>(storage)->throwCursorNotReady(methodName);
 
    MDB_val mdbKey, mdbValue;
    int result = static_cast<Storage<K, V>*>(storage)->_mdbCursorGet(handle, mdbKey, mdbValue, operation);
    if (result != MDB_SUCCESS)
        static_cast<Storage<K, V>*>(storage)->throwNotFoundOrUnknown(result, operationName);
 
    static_cast<Storage<K, V>*>(storage)->keySerializer.deserialize(mdbKey, key);
    static_cast<Storage<K, V>*>(storage)->valueSerializer.deserialize(mdbValue, value);
 
    if (state == openedPrivate)
        static_cast<Storage<K, V>*>(storage)->discoveredRecord(key, value);
    else
        static_cast<Storage<K, V>*>(storage)->discoveredRecord(key, value, static_cast<Storage<K, V>*>(storage)->_mdbCursorTxn(handle));
}