flyweight.hpp

Go to the documentation of this file.

 
/*
 * This is free and unencumbered software released into the public domain.
 *
 * Anyone is free to copy, modify, publish, use, compile, sell, or
 * distribute this software, either in source code form or as a compiled
 * binary, for any purpose, commercial or non-commercial, and by any
 * means.
 *
 * In jurisdictions that recognize copyright laws, the author or authors
 * of this software dedicate any and all copyright interest in the
 * software to the public domain. We make this dedication for the benefit
 * of the public at large and to the detriment of our heirs and
 * successors. We intend this dedication to be an overt act of
 * relinquishment in perpetuity of all present and future rights to this
 * software under copyright law.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * For more information, please refer to <http://unlicense.org/>
 */
#ifndef __FLYWEIGHT_HPP__
#define __FLYWEIGHT_HPP__
 
#include <functional>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>
 
namespace flyweight {
 
namespace detail {
    constexpr static size_t hash_combine(size_t a, size_t b) {
        return a ^ b + 0x9e3779b9 + (a << 6) + (a >> 2);
    }
 
    template<typename... Args>
    struct tuple_hasher {
        constexpr size_t operator()(const std::tuple<Args...>& value) const {
            return hash_tuple<std::tuple<Args...>, 0, Args...>(value);
        }
 
        template<typename TTuple, size_t I, typename T>
        constexpr static size_t hash_tuple(const TTuple& v) {
            return std::hash<T>{}(std::get<I>(v));
        }
 
        template<typename TTuple, size_t I, typename T1, typename T2, typename... Rest>
        constexpr static size_t hash_tuple(const TTuple& v) {
            return hash_combine(
                hash_tuple<TTuple, I, T1>(v),
                hash_tuple<TTuple, I+1, T2, Rest...>(v)
            );
        }
    };
 
    template<typename T>
    struct refcounted_value {
        T value;
        long long refcount;
 
        refcounted_value(T&& value) : value(value), refcount(0) {}
 
        operator T&() {
            return value;
        }
 
        refcounted_value& reference() {
            refcount++;
            return *this;
        }
 
        bool dereference() {
            --refcount;
            return refcount <= 0;
        }
    };
 
#if __cpp_lib_apply
    template<typename Fn, typename... Args>
    auto apply(Fn&& f, std::tuple<Args...>&& t) {
        return std::apply(std::move(f), std::move(t));
    }
#else
    // Unpacking tuple with int sequence on C++11
    // Reference: https://stackoverflow.com/a/7858971
    template<int...>
    struct seq {};
 
    template<int N, int... S>
    struct gens : gens<N-1, N-1, S...> {};
 
    template<int... S>
    struct gens<0, S...> {
        using type = seq<S...>;
    };
 
    template<typename... Args>
    struct apply_impl {
        template<typename Fn, int... S>
        static auto invoke(Fn&& f, std::tuple<Args...>&& t, seq<S...>) {
            return f(std::forward<Args>(std::get<S>(t))...);
        }
    };
 
    template<typename Fn, typename... Args>
    auto apply(Fn&& f, std::tuple<Args...>&& t) {
        return apply_impl<Args...>::invoke(std::move(f), std::move(t), typename gens<sizeof...(Args)>::type{});
    }
#endif
}
 
 
template<typename T, typename... Args>
struct default_creator {
    T operator()(Args&&... args) {
        return T { std::forward<Args>(args)... };
    }
};
 
template<typename T>
struct default_deleter {
    void operator()(T&) {
        // no-op
    }
};
 
template<typename T, typename Flyweight, typename ArgTuple>
struct autorelease_value {
    T& value;
 
    autorelease_value(T& value, Flyweight& flyweight, const ArgTuple& arg_tuple)
        : value(value)
        , flyweight(flyweight)
        , arg_tuple(arg_tuple)
    {
    }
 
    autorelease_value(const autorelease_value& other)
        : value(other.flyweight.get(other.arg_tuple))
        , flyweight(other.flyweight)
        , arg_tuple(other.arg_tuple)
    {
    }
    autorelease_value& operator=(const autorelease_value& other)
    {
        // release previous value
        flyweight.release(arg_tuple);
        // re-get the value to make sure reference counting is correct
        value = other.flyweight.get(other.arg_tuple);
        flyweight = other.flyweight;
        arg_tuple = other.arg_tuple;
    }
 
    T& operator*() {
        return value;
    }
    T& operator->() {
        return value;
    }
    operator T&() {
        return value;
    }
 
    ~autorelease_value() {
        flyweight.release(arg_tuple);
    }
 
private:
    Flyweight& flyweight;
    ArgTuple arg_tuple;
};
 
template<typename T, typename... Args>
class flyweight {
public:
    using value = T;
    using autorelease_value = autorelease_value<T, flyweight, std::tuple<Args...>>;
 
    flyweight() : creator(default_creator<T, Args...>{}), deleter(default_deleter<T>{}) {}
 
    template<typename Creator>
    flyweight(Creator&& creator)
        : creator([creator](Args&&... args) { return creator(std::forward<Args>(args)...); })
        , deleter(default_deleter<T>{})
    {
    }
 
    template<typename Creator, typename Deleter>
    flyweight(Creator&& creator, Deleter&& deleter)
        : creator([creator](Args&&... args) { return creator(std::forward<Args>(args)...); })
        , deleter([deleter](T& value) { deleter(value); })
    {
    }
 
    T& get(const std::tuple<Args...>& arg_tuple) {
        auto it = map.find(arg_tuple);
        if (it == map.end()) {
            it = map.emplace(arg_tuple, detail::apply(creator, (std::tuple<Args...>) arg_tuple)).first;
        }
        return it->second;
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto get(Args&&... args) -> typename std::enable_if<uses_multiple_args, T&>::type {
        return get(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
    autorelease_value get_autorelease(const std::tuple<Args...>& arg_tuple) {
        return {
            get(arg_tuple),
            *this,
            arg_tuple,
        };
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto get_autorelease(Args&&... args) -> typename std::enable_if<uses_multiple_args, autorelease_value>::type {
        return get_autorelease(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
    bool is_loaded(const std::tuple<Args...>& arg_tuple) const {
        return map.find(arg_tuple) != map.end();
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto is_loaded(Args&&... args) const -> typename std::enable_if<uses_multiple_args, bool>::type {
        return is_loaded(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
    bool release(const std::tuple<Args...>& arg_tuple) {
        auto it = map.find(arg_tuple);
        if (it != map.end()) {
            deleter(it->second);
            map.erase(it);
            return true;
        }
        else {
            return false;
        }
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto release(Args&&... args) -> typename std::enable_if<uses_multiple_args, bool>::type {
        return release(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
protected:
    std::unordered_map<std::tuple<Args...>, T, detail::tuple_hasher<Args...>> map;
    std::function<T(Args&&...)> creator;
    std::function<void(T&)> deleter;
};
 
 
template<typename T, typename... Args>
class flyweight_refcounted : public flyweight<detail::refcounted_value<T>, Args...> {
    using base = flyweight<detail::refcounted_value<T>, Args...>;
public:
    using autorelease_value = autorelease_value<T, flyweight_refcounted, std::tuple<Args...>>;
 
    flyweight_refcounted() : base() {}
 
    template<typename Creator>
    flyweight_refcounted(Creator&& creator) : base(creator) {}
 
    template<typename Creator, typename Deleter>
    flyweight_refcounted(Creator&& creator, Deleter&& deleter) : base(creator, deleter) {}
 
    T& get(const std::tuple<Args...>& arg_tuple) {
        auto& value = base::get(arg_tuple);
        return value.reference();
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto get(Args&&... args) -> typename std::enable_if<uses_multiple_args, T&>::type {
        return get(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
    autorelease_value get_autorelease(const std::tuple<Args...>& arg_tuple) {
        return {
            get(arg_tuple),
            *this,
            arg_tuple,
        };
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto get_autorelease(Args&&... args) -> typename std::enable_if<uses_multiple_args, autorelease_value>::type {
        return get_autorelease(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
    size_t reference_count(const std::tuple<Args...>& arg_tuple) const {
        auto it = base::map.find(arg_tuple);
        if (it != base::map.end()) {
            return it->second.refcount;
        }
        else {
            return 0;
        }
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto reference_count(Args&&... args) const -> typename std::enable_if<uses_multiple_args, size_t>::type {
        return reference_count(std::tuple<Args...> { std::forward<Args>(args)... });
    }
 
    bool release(const std::tuple<Args...>& arg_tuple) {
        auto it = base::map.find(arg_tuple);
        if (it != base::map.end() && it->second.dereference()) {
            base::deleter(it->second);
            base::map.erase(it);
            return true;
        }
        else {
            return false;
        }
    }
    template<bool uses_multiple_args = (sizeof...(Args) > 1)>
    auto release(Args&&... args) -> typename std::enable_if<uses_multiple_args, bool>::type {
        return release(std::tuple<Args...> { std::forward<Args>(args)... });
    }
};
 
}
 
# endif  // __FLYWEIGHT_HPP__