Attribute.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <vector>
#include <wmtk/utils/MerkleTreeInteriorNode.hpp>
#include "MapTypes.hpp"
#include "PerThreadAttributeScopeStacks.hpp"
#include "wmtk/attribute/internal/AttributeTransactionStack.hpp"
 
namespace wmtk {
class MeshWriter;
 
namespace attribute {
template <typename T, int Dim>
class AccessorBase;
 
template <typename T>
class PerThreadAttributeScopeStacks;
namespace internal {
template <typename T>
class AttributeTransactionStack;
} // namespace internal
 
template <typename T>
class Attribute : public wmtk::utils::Hashable
{
public:
    template <int D = Eigen::Dynamic>
    using MapResult = internal::MapResult<T, D>;
    template <int D = Eigen::Dynamic>
    using ConstMapResult = internal::ConstMapResult<T, D>;
 
 
    // attribute directly hashes its "children" components so it overrides "child_hashes"
    std::map<std::string, size_t> child_hashes() const override;
 
 
    template <typename U, int D>
    friend class AccessorBase;
    friend class internal::AttributeTransactionStack<T>;
    void serialize(const std::string& name, const int dim, MeshWriter& writer) const;
 
    Attribute(const std::string& name, int64_t dimension, T default_value = T(0), int64_t size = 0);
 
    Attribute(Attribute&& o);
    ~Attribute();
    Attribute& operator=(Attribute&& o);
 
    template <int D = Eigen::Dynamic>
    ConstMapResult<D> const_vector_attribute(const int64_t index) const;
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute(const int64_t index);
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute2(const int64_t index);
 
    T const_scalar_attribute(const int64_t index) const;
    T& scalar_attribute(const int64_t index);
    T const_scalar_attribute(const int64_t index, const int8_t offset) const;
    T& scalar_attribute(const int64_t index, const int8_t offset);
 
    void set(std::vector<T> val);
 
    int64_t reserved_size() const;
 
    int64_t dimension() const;
    void reserve(const int64_t size);
 
    const T& default_value() const;
 
    bool operator==(const Attribute<T>& o) const;
 
    void push_scope();
    void pop_scope(bool apply_updates);
    void rollback_current_scope();
 
    const internal::AttributeTransactionStack<T>& get_local_scope_stack() const;
    internal::AttributeTransactionStack<T>& get_local_scope_stack();
 
    void consolidate(const std::vector<int64_t>& new2old);
 
    void index_remap(const std::vector<T>& old2new);
    void index_remap(const std::vector<T>& old2new, const std::vector<Eigen::Index>& cols);
 
    template <int D = Eigen::Dynamic>
    ConstMapResult<D> const_vector_attribute(const int64_t index, const std::vector<T>& data) const;
 
    template <int D = Eigen::Dynamic>
    ConstMapResult<D> const_vector_attribute_from_start(
        const int64_t index,
        const std::vector<T>& data) const;
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute(const int64_t index, std::vector<T>& data) const;
 
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute_from_start(const int64_t index, std::vector<T>& data) const;
    T const_scalar_attribute(const int64_t index, const std::vector<T>& data) const;
    T& scalar_attribute(const int64_t index, std::vector<T>& data) const;
 
    T const_scalar_attribute(const int64_t index, const int8_t offset, const std::vector<T>& data)
        const;
    T& scalar_attribute(const int64_t index, const int8_t offset, std::vector<T>& data) const;
 
    // computes the "reserved size" but using the passed in data
    int64_t reserved_size(const std::vector<T>& data) const;
 
private:
    std::vector<T> m_data;
    PerThreadAttributeScopeStacks<T> m_scope_stacks;
    int64_t m_dimension = -1;
    T m_default_value = T(0);
 
public:
    std::string m_name;
};
 
template <typename T>
template <int D>
inline auto Attribute<T>::const_vector_attribute(const int64_t index) const -> ConstMapResult<D>
{
    return const_vector_attribute<D>(index, m_data);
}
 
template <typename T>
template <int D>
inline auto Attribute<T>::const_vector_attribute(const int64_t index, const std::vector<T>& data)
    const -> ConstMapResult<D>
{
    assert(index < reserved_size(data));
    assert(data.size() % m_dimension == 0);
    const int64_t start = index * m_dimension;
    return const_vector_attribute_from_start<D>(start, data);
}
template <typename T>
template <int D>
inline auto Attribute<T>::const_vector_attribute_from_start(
    const int64_t start,
    const std::vector<T>& data) const -> ConstMapResult<D>
{
    assert(m_dimension > 0);
    if constexpr (D != Eigen::Dynamic) {
        assert(D == m_dimension);
    }
    ConstMapResult<D> R(data.data() + start, m_dimension);
 
    assert(R.size() == m_dimension);
 
    return R;
}
 
 
template <typename T>
template <int D>
inline auto Attribute<T>::vector_attribute(const int64_t index) -> MapResult<D>
{
    // return MapResult<D>(m_data.data(), m_dimension);
    return vector_attribute<D>(index, m_data);
}
 
template <typename T>
template <int D>
inline auto Attribute<T>::vector_attribute2(const int64_t index) -> MapResult<D>
{
    return MapResult<D>(m_data.data(), m_dimension);
    // return vector_attribute<D>(index, m_data);
}
 
template <typename T>
template <int D>
inline auto Attribute<T>::vector_attribute(const int64_t index, std::vector<T>& data) const
    -> MapResult<D>
{
    assert(index < reserved_size(data));
    assert(data.size() % m_dimension == 0);
    const int64_t start = index * m_dimension;
    return vector_attribute_from_start<D>(start, data);
}
 
template <typename T>
template <int D>
inline auto Attribute<T>::vector_attribute_from_start(const int64_t start, std::vector<T>& data)
    const -> MapResult<D>
{
    assert(m_dimension > 0);
    if constexpr (D != Eigen::Dynamic) {
        assert(D == m_dimension);
    }
    // assert(start < data.size());
    // assert(start + m_dimension < data.size());
    MapResult<D> R(data.data() + start, m_dimension);
    assert(R.size() == m_dimension);
    return R;
}
 
template <typename T>
inline T Attribute<T>::const_scalar_attribute(const int64_t index) const
{
    return const_scalar_attribute(index, m_data);
}
template <typename T>
inline T Attribute<T>::const_scalar_attribute(const int64_t index, const std::vector<T>& data) const
{
    assert(index < reserved_size(data));
    assert(m_dimension == 1);
    return data[index];
}
 
template <typename T>
inline T& Attribute<T>::scalar_attribute(const int64_t index)
{
    return scalar_attribute(index, m_data);
}
template <typename T>
inline T& Attribute<T>::scalar_attribute(const int64_t index, std::vector<T>& data) const
{
    assert(index < reserved_size(data));
    assert(m_dimension == 1);
    return data[index];
}
 
template <typename T>
inline T Attribute<T>::const_scalar_attribute(const int64_t index, const int8_t offset) const
{
    return const_scalar_attribute(index, offset, m_data);
}
template <typename T>
inline T Attribute<T>::const_scalar_attribute(
    const int64_t index,
    const int8_t offset,
    const std::vector<T>& data) const
{
    const int64_t idx = index * m_dimension + offset;
    assert(index < reserved_size(data));
    return data[idx];
}
 
template <typename T>
inline T& Attribute<T>::scalar_attribute(const int64_t index, const int8_t offset)
{
    return scalar_attribute(index, offset, m_data);
}
template <typename T>
inline T&
Attribute<T>::scalar_attribute(const int64_t index, const int8_t offset, std::vector<T>& data) const
{
    const int64_t idx = index * m_dimension + offset;
    assert(index < reserved_size(data));
    return data[idx];
}
 
 
template <typename T>
inline int64_t Attribute<T>::dimension() const
{
    return m_dimension;
}
 
template <typename T>
inline const T& Attribute<T>::default_value() const
{
    return m_default_value;
}
 
template <typename T>
inline const internal::AttributeTransactionStack<T>& Attribute<T>::get_local_scope_stack() const
{
    return m_scope_stacks.local();
}
template <typename T>
inline internal::AttributeTransactionStack<T>& Attribute<T>::get_local_scope_stack()
{
    return m_scope_stacks.local();
}
 
template <typename T>
inline void Attribute<T>::push_scope()
{
    m_scope_stacks.local().emplace();
}
template <typename T>
inline void Attribute<T>::pop_scope(bool apply_updates)
{
    m_scope_stacks.local().pop(*this, apply_updates);
}
 
template <typename T>
inline void Attribute<T>::rollback_current_scope()
{
    m_scope_stacks.local().rollback_current_scope(*this);
}
 
} // namespace attribute
} // namespace wmtk
#include "AccessorBase.hpp"
#include "AttributeCache.hpp"