lmdbal/cache.hpp

// Squawk messenger. 
// Copyright (C) 2019  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/>.

#ifndef LMDBDATABASE_CACHE_HPP
#define LMDBDATABASE_CACHE_HPP

#include "cache.h"
#include "exceptions.h"

template<class K, class V>
LMDBDataBase::Cache<K, V>::Cache(const std::string& p_name, DataBase* parent):
    Storage<K, V>(p_name, parent),
    mode(new Mode),
    cache(new std::map<K, V>()),
    abscent(new std::set<K>()),
    sizeDifference(new uint32_t)
{
    *mode = Mode::nothing;
    *sizeDifference = 0;
}

template<class K, class V>
LMDBDataBase::Cache<K, V>::~Cache() {
    delete sizeDifference;
    delete mode;
    delete cache;
    delete abscent;
}

template<class K, class V>
void LMDBDataBase::Cache<K, V>::addRecord(const K& key, const V& value) {
    StorageBase::ensureOpened(StorageBase::addRecordMethodName);

    if (cache->count(key) > 0)
        StorageBase::throwDuplicate(StorageBase::toString(key));

    Storage<K, V>::addRecord(key, value);
    cache->insert(std::make_pair(key, value));

    if (*mode != Mode::full)
        abscent->erase(key);
}

template<class K, class V>
bool LMDBDataBase::Cache<K, V>::forceRecord(const K& key, const V& value) {
    StorageBase::ensureOpened(StorageBase::forceRecordMethodName);

    bool added = Storage<K, V>::forceRecord(key, value);
    if (*mode == Mode::full) {
        (*cache)[key] = value;
    } else {
        if (added)
            abscent->erase(key);

        std::pair<typename std::map<K, V>::iterator, bool> result = cache->insert(std::make_pair(key, value));
        if (!result.second)
            result.first->second = value;
        else if (!added)    //this way database had value but cache didn't, so, need to decrease sizeDifference
            handleMode();
    }

    return added;
}

template<class K, class V>
void LMDBDataBase::Cache<K, V>::changeRecord(const K& key, const V& value) {
    StorageBase::ensureOpened(StorageBase::changeRecordMethodName);

    if (*mode == Mode::full) {
        typename std::map<K, V>::iterator itr = cache->find(key);
        if (itr == cache->end())
            StorageBase::throwNotFound(StorageBase::toString(key));

        Storage<K, V>::changeRecord(key, value);
        itr->second = value;
    } else {
        if (abscent->count(key) > 0)
            StorageBase::throwNotFound(StorageBase::toString(key));

        try {
            Storage<K, V>::changeRecord(key, value);
            typename std::pair<typename std::map<K, V>::iterator, bool> res = cache->insert(std::make_pair(key, value));
            if (!res.second)
                res.first->second = value;
            else
                handleMode();
        } catch (const NotFound& error) {
            abscent->insert(key);
            throw error;
        }
    }
}

template<class K, class V>
V LMDBDataBase::Cache<K, V>::getRecord(const K& key) const {
    StorageBase::ensureOpened(StorageBase::getRecordMethodName);

    typename std::map<K, V>::const_iterator itr = cache->find(key);
    if (itr != cache->end())
        return itr->second;

    if (*mode == Mode::full || abscent->count(key) != 0)
        StorageBase::throwNotFound(StorageBase::toString(key));

    try {
        V value = Storage<K, V>::getRecord(key);
        cache->insert(std::make_pair(key, value));
        handleMode();
        return value;
    } catch (const NotFound& error) {
        if (*mode != Mode::full)
            abscent->insert(key);

        throw error;
    }
}

template<class K, class V>
bool LMDBDataBase::Cache<K, V>::checkRecord(const K& key) const {
    StorageBase::ensureOpened(StorageBase::checkRecordMethodName);

    typename std::map<K, V>::const_iterator itr = cache->find(key);
    if (itr != cache->end())
        return true;

    if (*mode == Mode::full || abscent->count(key) != 0)
        return false;

    try {
        V value = Storage<K, V>::getRecord(key);
        cache->insert(std::make_pair(key, value));
        handleMode();
        return true;
    } catch (const NotFound& error) {
        if (*mode != Mode::full)
            abscent->insert(key);

        return false;
    }
}

template<class K, class V>
std::map<K, V> LMDBDataBase::Cache<K, V>::readAll() const {
    StorageBase::ensureOpened(StorageBase::readAllMethodName);

    if (*mode != Mode::full) {              //there is a room for optimization
        *mode = Mode::full;                 //I can read and deserialize only those values
        *cache = Storage<K, V>::readAll();  //that are missing in the cache
        abscent->clear();
        *sizeDifference = 0;
    }

    return *cache;
}

template<class K, class V>
void LMDBDataBase::Cache<K, V>::replaceAll(const std::map<K, V>& data) {
    Storage<K, V>::replaceAll(data);
    *cache = data;

    if (*mode != Mode::full) {
        *mode = Mode::full;
        abscent->clear();
        *sizeDifference = 0;
    }
}

template<class K, class V>
uint32_t LMDBDataBase::Cache<K, V>::addRecords(const std::map<K, V>& data, bool overwrite) {
    uint32_t newSize = Storage<K, V>::addRecords(data, overwrite);

    Mode& m = *mode;
    if (m == Mode::nothing)
        m = Mode::size;

    std::map<K, V>& c = *cache;
    std::set<K>& a = *abscent;
    for (const std::pair<const K, V>& pair : data) {
        std::pair<typename std::map<K, V>::iterator, bool> res = c.insert(pair);
        if (!res.second) {
            if (overwrite)
                res.first->second = pair.second;
        } else if (m != Mode::full) {
            a.erase(pair.first);
        }
    }

    if (m != Mode::full) {
        *sizeDifference = newSize - c.size();
        if (*sizeDifference == 0) {
            *mode = Mode::full;
            abscent->clear();
        }
    }

    return newSize;
}

template<class K, class V>
void LMDBDataBase::Cache<K, V>::removeRecord(const K& key) {
    StorageBase::ensureOpened(StorageBase::removeRecordMethodName);

    typename std::pair<typename std::set<K>::const_iterator, bool> pair = abscent->insert(key);
    if (!pair.second)
        StorageBase::throwNotFound(StorageBase::toString(key));

    Storage<K, V>::removeRecord(key);
    if (cache->erase(key) == 0)     //if it was not cached and we are now in size mode then the sizeDifference would decrease
        handleMode();

    if (*mode != Mode::full)
        abscent->insert(key);
}

template<class K, class V>
uint32_t LMDBDataBase::Cache<K, V>::count() const {
    switch (*mode) {
        case Mode::nothing:
        {
            uint32_t sz = Storage<K, V>::count();
            *sizeDifference = sz - cache->size();
            if (sz == 0) {
                *mode = Mode::full;
                abscent->clear();
            } else {
                *mode = Mode::size;
            }
            return sz;
        }
        case Mode::size:
            return cache->size() + *sizeDifference;
        case Mode::full:
            return cache->size();
        default:
            return 0;   //unreachable, no such state, just to suppress the waring
    }
}

template<class K, class V>
void LMDBDataBase::Cache<K, V>::handleMode() const {
    if (*mode == Mode::size) {
        --(*sizeDifference);
        if (*sizeDifference == 0) {
            *mode = Mode::full;
            abscent->clear();
        }
    }
}

template<class K, class V>
int LMDBDataBase::Cache<K, V>::drop(MDB_txn * transaction) {
    int res = Storage<K, V>::drop(transaction);
    cache->clear();
    abscent->clear();
    *mode = Mode::full;
    *sizeDifference = 0;
    return res;
}

#endif //LMDBDATABASE_CACHE_HPP