AttributeHandle.h

#pragma once
#include "Engine/Attribute/Attribute.h"
#include "Engine/Core/Types.h"
#include "tbb/concurrent_vector.h"
#include <memory>
#include <optional>
#include <span>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
 
#include <iostream>
 
namespace enzo::attr {
 
template <typename T> class AttributeHandle
{
  public:
    attr::AttributeType type_;
 
    AttributeHandle(std::shared_ptr<Attribute> attribute)
    {
        if (attribute == nullptr)
            throw std::runtime_error("Cannot pass empty pointer to AttributeHandle constructor");
        type_ = attribute->getType();
        name_ = attribute->getName();
        data_ = std::get<std::shared_ptr<StoreContainer<T>>>(attribute->store_);
    }
 
    void addValue(T value)
    {
        // TODO:make this private (primitive friend classes only)
        data_->push_back(value);
    }
 
    // /**
    // * @brief Reserves more space in the attribute to add new elements
    // *
    // * This is important when adding many elements to the attribute as automatic resizing is
    // expensive.
    // *
    // * @param newCap The new maximum number of elements the attribute can hold before needing to
    // automatically allocate more.
    // *
    // */
    // void reserve(std::size_t newCap)
    // {
    //     data_->reserve(newCap);
    // }
 
    void resize(std::size_t newSize) { data_->resize(newSize); }
 
    // TODO: replace with iterator
    std::vector<T> getAllValues() const { return {data_->begin(), data_->end()}; }
 
    size_t getSize() const { return data_->size(); }
 
    T getValue(size_t offset) const { return (*data_)[offset]; }
 
    const T& operator[](size_t offset) const
        requires(!std::is_same_v<T, boolT>)
    {
        return (*data_)[offset];
    }
 
    std::span<const T> getSpan() const { return {data_->data(), data_->size()}; }
 
    void setValue(size_t offset, const T& value) { (*data_)[offset] = value; }
 
    std::string getName() const { return name_; }
 
  private:
    std::string name_;
 
    std::shared_ptr<StoreContainer<T>> data_;
 
    // int typeID_;
};
 
using AttributeHandleInt = AttributeHandle<intT>;
using AttributeHandleFloat = AttributeHandle<floatT>;
using AttributeHandleVector3 = AttributeHandle<enzo::Vector3>;
using AttributeHandleBool = AttributeHandle<enzo::boolT>;
using AttributeHandleMatrix4 = AttributeHandle<enzo::Matrix4>;
 
template <typename T>
class AttributeHandleRO
{
  public:
    attr::AttributeType type_;
 
    AttributeHandleRO(std::shared_ptr<const Attribute> attribute)
    {
        type_ = attribute->getType();
        name_ = attribute->getName();
        data_ = std::get<std::shared_ptr<StoreContainer<T>>>(attribute->store_);
    }
 
    std::vector<T> getAllValues() const { return {data_->begin(), data_->end()}; }
 
    size_t getSize() const { return data_->size(); }
 
    T getValue(size_t offset) const
    {
        // TODO:protect against invalid positions
        // TODO: cast types
        // TODO: consider removing range check for faster reads
        if (offset >= data_->size())
            throw std::out_of_range(
                "Cannot get offset: " + std::to_string(offset) +
                " from size: " + std::to_string(data_->size()) + " for attribute: " + name_
            );
        return (*data_)[offset];
    }
 
    const T& operator[](size_t offset) const
        requires(!std::is_same_v<T, boolT>)
    {
        return (*data_)[offset];
    }
 
    std::string getName() const { return name_; }
 
  private:
    std::string name_;
 
    std::shared_ptr<StoreContainer<T>> data_;
 
    // int typeID_;
};
 
using AttributeHandleInt = AttributeHandle<intT>;
using AttributeHandleFloat = AttributeHandle<floatT>;
using AttributeHandleVector3 = AttributeHandle<enzo::Vector3>;
using AttributeHandleBool = AttributeHandle<enzo::boolT>;
using AttributeHandleMatrix4 = AttributeHandle<enzo::Matrix4>;
 
} // namespace enzo::attr