cache.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * 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, version 3.
 *
 * 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.
 */
#ifndef PLASK__UTILS_CACHE_H
#define PLASK__UTILS_CACHE_H
 
#include <map>
#include "../memory.hpp"
 
namespace plask {
 
template <typename Key, typename ValuePtr>
struct CacheRemoveStrategyBase {
 
    std::map<Key*, ValuePtr> map;
 
};
 
template <typename Key, typename ValuePtr>
struct CacheRemoveOnlyWhenDeleted: public CacheRemoveStrategyBase<Key, ValuePtr> {
 
    void onEvent(typename Key::Event& evt) {
        if (evt.isDelete()) this->map.erase(&evt.source());
    }
 
};
 
template <typename Key, typename ValuePtr>
struct CacheRemoveOnEachChange: public CacheRemoveStrategyBase<Key, ValuePtr> {
 
    void onEvent(typename Key::Event& evt) {
        auto* src = evt.source();
        src->changedDisconnectMethod(this, &CacheRemoveOnEachChange::onEvent);
        this->map.erase(src);
    }
 
};
 
template <typename Key, typename ValuePtr, template<typename SKey, typename SValuePtr> class DeleteStrategy = CacheRemoveOnlyWhenDeleted >
struct CacheBase: public DeleteStrategy<Key, ValuePtr> {
 
    typedef typename ValuePtr::element_type Value;
 
    ~CacheBase() {
        clear();
    }
 
    void append(Key* index, ValuePtr value) {
        this->map[index] = value;
       // index->changed.at_front(boost::bind(method, obj, _1));
        index->changedConnectMethod(this, &DeleteStrategy<Key, ValuePtr>::onEvent, boost::signals2::at_front);
    }
 
    void append(plask::shared_ptr<Key> index, ValuePtr value) {
        append(index.get(), value);
    }
 
    plask::shared_ptr<Value> operator()(Key* index, Value* value) {
        plask::shared_ptr<Value> result(value);
        this->append(index, result);
        return result;
    }
 
    plask::shared_ptr<Value> operator()(Key* index, shared_ptr<Value> value) {
        this->append(index, value);
        return value;
    }
 
    plask::shared_ptr<Value> operator()(plask::shared_ptr<Key> index, Value* value) {
        plask::shared_ptr<Value> result(value);
        this->append(index, result);
        return result;
    }
 
    plask::shared_ptr<Value> operator()(plask::shared_ptr<Key> index, shared_ptr<Value> value) {
        this->append(index, value);
        return value;
    }
 
    void clear() {
        for (auto i: this->map)
            i.first->changedDisconnectMethod(this, &DeleteStrategy<Key, ValuePtr>::onEvent);
        this->map.clear();
    }
 
};
 
template <typename Key, typename Value, template<typename SKey, typename SValuePtr> class DeleteStrategy = CacheRemoveOnlyWhenDeleted >
struct WeakCache: public CacheBase<Key, plask::weak_ptr<Value>, DeleteStrategy> {
 
    plask::shared_ptr<Value> get(Key* index) {
        auto iter = this->map.find(index);
        if (iter != this->map.end()) {
            if (auto res = iter->second.lock())
                return res;
            else {
                iter->first->changedDisconnectMethod(this, &DeleteStrategy<Key, plask::weak_ptr<Value> >::onEvent);
                this->map.erase(iter);
            }
        }
        return plask::shared_ptr<Value>();
    }
 
    plask::shared_ptr<Value> get(plask::shared_ptr<Key> index) {
        return get(index.get());
    }
 
    plask::shared_ptr<Value> get(Key* index) const {
        auto constr_iter = this->map.find(index);
        if (constr_iter != this->map.end()) {
            if (auto res = constr_iter->second.lock())
                return res;
        }
        return plask::shared_ptr<Value>();
    }
 
    plask::shared_ptr<Value> get(plask::shared_ptr<Key> index) const {
        return get(index.get());
    }
 
    void cleanDeleted() {
        for(auto i = this->map.begin(); i != this->map.end(); )
            if (i->second.expired()) {
                i->first.changedDisconnectMethod(this, &DeleteStrategy<Key, plask::weak_ptr<Value> >::onEvent);
                this->map.erase(i++);
            }
                else ++i;
    }
 
};
 
template <typename Key, typename Value, template<typename SKey, typename SValuePtr> class DeleteStrategy = CacheRemoveOnlyWhenDeleted >
struct StrongCache: public CacheBase<Key, plask::shared_ptr<Value>, DeleteStrategy> {
 
    plask::shared_ptr<Value> get(Key* index) const {
        auto iter = this->map.find(index);
        return iter != this->map.end() ? iter->second : plask::shared_ptr<Value>();
    }
 
    plask::shared_ptr<Value> get(plask::shared_ptr<Key> index) const {
        return get(index.get());
    }
 
};
 
}   // namespace plask
 
 
#endif // CACHE_H