Attribute.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <vector>
#include <wmtk/utils/MerkleTreeInteriorNode.hpp>
#include "MapTypes.hpp"
 
namespace wmtk {
class MeshWriter;
 
namespace attribute {
 
 
template <typename T>
class Attribute : public wmtk::utils::Hashable
{
public:
    using Scalar = T;
    // typedefs
    template <int D = Eigen::Dynamic>
    using MapResult = MapResult<T, D>;
    template <int D = Eigen::Dynamic>
    using ConstMapResult = ConstMapResult<T, D>;
 
 
    // attribute directly hashes its "children" components so it overrides "child_hashes"
    std::map<std::string, size_t> child_hashes() const override;
 
 
    void serialize(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& operator=(Attribute&& o);
 
    Attribute(const Attribute& o) = delete;
    Attribute& operator=(const Attribute&& o) = delete;
 
    ~Attribute() override;
 
    template <int D = Eigen::Dynamic>
    ConstMapResult<D> const_vector_attribute(int64_t index) const;
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute(int64_t index);
 
    const T& const_scalar_attribute(int64_t index) const;
    T& scalar_attribute(int64_t index);
    template <int D = Eigen::Dynamic>
    const T& const_vector_single_value(int64_t index, int8_t vector_index) const;
    template <int D = Eigen::Dynamic>
    T& vector_single_value(int64_t index, int8_t vector_index);
 
    void set(std::vector<T> val);
 
    int64_t reserved_size() const;
 
    int64_t dimension() const;
    void reserve(int64_t size);
 
    const T& default_value() const;
 
    bool operator==(const Attribute<T>& o) const;
 
 
 
    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(int64_t index, const std::vector<T>& data) const;
 
    template <int D = Eigen::Dynamic>
    ConstMapResult<D> const_vector_attribute_without_stride(
        int64_t index,
        const std::vector<T>& data) const;
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute(int64_t index, std::vector<T>& data) const;
 
    template <int D = Eigen::Dynamic>
    MapResult<D> vector_attribute_without_stride(int64_t index, std::vector<T>& data) const;
    const T& const_scalar_attribute(int64_t index, const std::vector<T>& data) const;
    T& scalar_attribute(int64_t index, std::vector<T>& data) const;
 
    template <int D = Eigen::Dynamic>
    const T& const_vector_single_value(
        int64_t index,
        int8_t vector_index,
        const std::vector<T>& data) const;
    template <int D = Eigen::Dynamic>
    T& vector_single_value(
        int64_t index,
        int8_t vector_index,
        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;
 
    const std::string& name() const;
    void set_name(const std::string& name) { m_name = name; }
 
protected:
    std::vector<T> m_data;
    int64_t m_dimension = -1;
    T m_default_value = T(0);
 
    std::string m_name;
 
public:
};
 
 
} // namespace attribute
} // namespace wmtk
#if !defined(WMTK_ENABLED_DEV_MODE)
#include "Attribute.hxx"
#endif