AttributeCollection.hpp

#pragma once
 
#include <wmtk/utils/VectorUtils.h>
#include <wmtk/utils/Logger.hpp>
 
#include <wmtk/threading/enumerable_thread_specific.hpp>
 
#include <algorithm>
#include <array>
#include <cassert>
#include <map>
#include <optional>
#include <unordered_map>
#include <vector>
 
namespace wmtk {
class AbstractAttributeContainer
{
public:
    virtual ~AbstractAttributeContainer() = default;
    virtual void move(size_t from, size_t to) {};
    virtual void resize(size_t) = 0;
    virtual void reset_from(size_t first) = 0;
    virtual void clear() = 0;
    virtual void rollback() = 0;
    virtual void begin_protect() = 0;
    virtual void end_protect() = 0;
    virtual void append_recorded(std::vector<size_t>& out) {}
};
 
 
template <typename T>
struct AttributeCollection : public AbstractAttributeContainer
{
    void move(size_t from, size_t to) override
    {
        if (from == to) return;
        m_attributes[to] = std::move(m_attributes[from]);
    }
    // In the preallocated model this sets the storage capacity: it is called
    // (single-threaded) at init / consolidation with the reserved size. It is
    // grow-only so live data below `s` is never dropped. During operations the
    // storage is never resized -- operations only fail when they run out of the
    // preallocated slots.
    void resize(size_t s) override
    {
        if (s > m_attributes.size()) m_attributes.resize(s);
    }
    void reset_from(size_t first) override
    {
        for (size_t i = first; i < m_attributes.size(); ++i) m_attributes[i] = T{};
    }
    void clear() override { m_attributes.clear(); }
 
    void rollback() override
    {
        for (auto& [i, v] : m_rollback_list.local()) {
            m_attributes[i] = std::move(v);
        }
        end_protect();
    }
    void begin_protect() override
    {
        m_rollback_list.local().clear();
        recording.local() = true;
    };
    void end_protect() override
    {
        m_rollback_list.local().clear();
        recording.local() = false;
    }
    void append_recorded(std::vector<size_t>& out) override
    {
        for (const auto& kv : m_rollback_list.local()) out.push_back(kv.first);
    }
 
    const T& at(size_t i) const { return m_attributes[i]; }
 
    const T& operator[](size_t i) const { return at(i); }
 
    T& operator[](size_t i)
    {
        if (recording.local()) {
            m_rollback_list.local().emplace(i, m_attributes[i]);
        }
        return m_attributes[i];
    }
 
 
    size_t size() const { return m_attributes.size(); }
    wmtk::threading::enumerable_thread_specific<std::unordered_map<size_t, T>> m_rollback_list;
    // Plain preallocated storage: never grows during operations.
    std::vector<T> m_attributes;
    wmtk::threading::enumerable_thread_specific<bool> recording{false};
};
 
class AttributeContainerGroup : public AbstractAttributeContainer
{
public:
    void add(AbstractAttributeContainer* c) { m_children.push_back(c); }
 
    void move(size_t from, size_t to) override
    {
        for (auto* c : m_children) c->move(from, to);
    }
    void resize(size_t s) override
    {
        for (auto* c : m_children) c->resize(s);
    }
    void reset_from(size_t first) override
    {
        for (auto* c : m_children) c->reset_from(first);
    }
    void clear() override
    {
        for (auto* c : m_children) c->clear();
    }
    void rollback() override
    {
        for (auto* c : m_children) c->rollback();
    }
    void begin_protect() override
    {
        for (auto* c : m_children) c->begin_protect();
    }
    void end_protect() override
    {
        for (auto* c : m_children) c->end_protect();
    }
    void append_recorded(std::vector<size_t>& out) override
    {
        for (auto* c : m_children) c->append_recorded(out);
    }
 
private:
    std::vector<AbstractAttributeContainer*> m_children;
};
} // namespace wmtk