memoize.hpp

#pragma once
 
#include <functional>
#include <tuple>
#include <unordered_map>
 
namespace z {
namespace core {
 
// Hashing helper
namespace memoization {
 
template <typename T>
inline void hash_combine(std::size_t &seed, const T &val) {
    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
 
template <typename tuple, std::size_t index = std::tuple_size<tuple>::value - 1>
struct tupleHasher {
    static void apply(std::size_t &seed, const tuple &tup) {
        tupleHasher<tuple, index - 1>::apply(seed, tup);
        hash_combine(seed, std::get<index>(tup));
    }
};
 
template <typename tuple>
struct tupleHasher<tuple, 0> {
    static void apply(std::size_t &seed, const tuple &tup) {
        hash_combine(seed, std::get<0>(tup));
    }
};
 
struct tupleHash {
    template <typename... T>
    std::size_t operator()(const std::tuple<T...> &t) const {
        std::size_t seed = 0;
        tupleHasher<std::tuple<T...>>::apply(seed, t);
        return seed;
    }
};
} // namespace memoization
 
template <typename T>
class memoize;
 
template <typename R, typename... Args>
class memoize<R(Args...)> {
private:
    std::function<R(Args...)> lambda;
    std::unordered_map<std::tuple<Args...>, R, memoization::tupleHash> cache;
 
public:
    memoize(std::function<R(Args...)> &&lambda) : lambda(lambda) {}
 
    memoize(R lambda(Args...)) : lambda(lambda) {}
 
    memoize() = delete;
 
    R operator()(Args... args) {
        auto arg_list = std::make_tuple(args...);
 
        if (cache.find(arg_list) == cache.end()) {
            cache[arg_list] = lambda(args...);
        }
        return cache[arg_list];
    }
 
    void clear() {
        cache.clear();
    }
};
 
} // namespace core
} // namespace z