project name change

src/cache.hpp

@@ -0,0 +1,273 @@
+// 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 LMDBAL_CACHE_HPP
+#define LMDBAL_CACHE_HPP
+
+#include "cache.h"
+#include "exceptions.h"
+
+template<class K, class V>
+LMDBAL::Cache<K, V>::Cache(const std::string& p_name, Base* 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>
+LMDBAL::Cache<K, V>::~Cache() {
+    delete sizeDifference;
+    delete mode;
+    delete cache;
+    delete abscent;
+}
+
+template<class K, class V>
+void LMDBAL::Cache<K, V>::addRecord(const K& key, const V& value) {
+    iStorage::ensureOpened(iStorage::addRecordMethodName);
+
+    if (cache->count(key) > 0)
+        iStorage::throwDuplicate(iStorage::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 LMDBAL::Cache<K, V>::forceRecord(const K& key, const V& value) {
+    iStorage::ensureOpened(iStorage::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 LMDBAL::Cache<K, V>::changeRecord(const K& key, const V& value) {
+    iStorage::ensureOpened(iStorage::changeRecordMethodName);
+
+    if (*mode == Mode::full) {
+        typename std::map<K, V>::iterator itr = cache->find(key);
+        if (itr == cache->end())
+            iStorage::throwNotFound(iStorage::toString(key));
+
+        Storage<K, V>::changeRecord(key, value);
+        itr->second = value;
+    } else {
+        if (abscent->count(key) > 0)
+            iStorage::throwNotFound(iStorage::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 LMDBAL::Cache<K, V>::getRecord(const K& key) const {
+    iStorage::ensureOpened(iStorage::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)
+        iStorage::throwNotFound(iStorage::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 LMDBAL::Cache<K, V>::checkRecord(const K& key) const {
+    iStorage::ensureOpened(iStorage::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> LMDBAL::Cache<K, V>::readAll() const {
+    iStorage::ensureOpened(iStorage::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 LMDBAL::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 LMDBAL::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 LMDBAL::Cache<K, V>::removeRecord(const K& key) {
+    iStorage::ensureOpened(iStorage::removeRecordMethodName);
+
+    typename std::pair<typename std::set<K>::const_iterator, bool> pair = abscent->insert(key);
+    if (!pair.second)
+        iStorage::throwNotFound(iStorage::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 LMDBAL::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 LMDBAL::Cache<K, V>::handleMode() const {
+    if (*mode == Mode::size) {
+        --(*sizeDifference);
+        if (*sizeDifference == 0) {
+            *mode = Mode::full;
+            abscent->clear();
+        }
+    }
+}
+
+template<class K, class V>
+int LMDBAL::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 //LMDBAL_CACHE_HPP