view_pool.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <memory>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <pulp/view/view.hpp>
 
namespace pulp::view {

class ViewPool {
public:
    static constexpr std::size_t kDefaultPerClassCap = 32;
 
    ViewPool() = default;
    explicit ViewPool(std::size_t per_class_cap) : per_class_cap_(per_class_cap) {}
 
    ViewPool(const ViewPool&) = delete;
    ViewPool& operator=(const ViewPool&) = delete;

    template <class T, class Factory>
    std::unique_ptr<T> acquire(Factory&& make) {
        static_assert(std::is_base_of_v<View, T>,
                      "ViewPool::acquire<T>: T must derive from pulp::view::View");
        if (auto recycled = take(std::type_index(typeid(T)))) {
            recycled->prepare_for_reuse();
            return std::unique_ptr<T>(static_cast<T*>(recycled.release()));
        }
        return std::forward<Factory>(make)();
    }

    std::unique_ptr<View> acquire(std::type_index key);

    void release(std::unique_ptr<View> view);

    void set_per_class_cap(std::size_t cap) { per_class_cap_ = cap; }
    std::size_t per_class_cap() const { return per_class_cap_; }

    void clear() { free_lists_.clear(); }

    std::size_t size(std::type_index key) const {
        auto it = free_lists_.find(key);
        return it == free_lists_.end() ? 0 : it->second.size();
    }

    std::size_t total_size() const {
        std::size_t n = 0;
        for (const auto& [key, list] : free_lists_) n += list.size();
        return n;
    }
 
private:
    std::unique_ptr<View> take(std::type_index key);
 
    std::size_t per_class_cap_ = kDefaultPerClassCap;
    std::unordered_map<std::type_index, std::vector<std::unique_ptr<View>>> free_lists_;
};
 
}  // namespace pulp::view