AttributeHandle.h

#pragma once
#include <memory>
#include <stdexcept>
#include <string>
#include <optional>
#include <vector>
#include "Engine/Operator/Attribute.h"
#include "Engine/Types.h"
#include "tbb/concurrent_vector.h"
 
#include <iostream>
 
 
namespace enzo::ga{
 
template <typename T>
class AttributeHandle
{
public:
    ga::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();
        // get attribute data pointer
        // TODO: check types match
        // TODO: add the other types
 
        // int
        if constexpr (std::is_same<bt::intT, T>::value)
        {
            data_=attribute->intStore_;
        }
 
        // float
        else if constexpr (std::is_same<bt::floatT, T>::value)
        {
            data_=attribute->floatStore_;
        }
 
        // vector 3
        else if constexpr (std::is_same<enzo::bt::Vector3, T>::value)
        {
            data_=attribute->vector3Store_;
        }
        else if constexpr (std::is_same<enzo::bt::boolT, T>::value)
        {
            data_=attribute->boolStore_;
        }
        else if constexpr (std::is_same<enzo::bt::Matrix4, T>::value)
        {
            data_=attribute->matrix4Store_;
        }
        else
        {
                throw std::runtime_error("Type " + std::to_string(static_cast<int>(type_)) + " was not properly accounted for in AttributeHandle constructor");
        }
    }
 
    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
    {
        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];
    }
 
    void setValue(size_t offset, const T& value)
    {
        (*data_)[offset] = value;
    }
 
    std::string getName() const
    {
        return name_;
    }
 
 
 
private:
    // private attributes are attributes that are hidden from the user
    // for internal use
    bool private_=false;
    // hidden attributes are user accessible attributes that the user may
    // or may want to use
    bool hidden_=false;
    // allows the user to read the attributeHandle but not modify it
    bool readOnly_=false;
 
    std::string name_;
 
    std::shared_ptr<StoreContainer<T>> data_;
 
    // int typeID_;
 
};
 
using AttributeHandleInt = AttributeHandle<bt::intT>;
using AttributeHandleFloat = AttributeHandle<bt::floatT>;
using AttributeHandleVector3 = AttributeHandle<enzo::bt::Vector3>;
using AttributeHandleBool = AttributeHandle<enzo::bt::boolT>;
using AttributeHandleMatrix4 = AttributeHandle<enzo::bt::Matrix4>;
 
template <typename T>
class AttributeHandleRO
{
public:
    ga::AttributeType type_;
 
    AttributeHandleRO(std::shared_ptr<const Attribute> attribute)
    {
        type_ = attribute->getType();
        name_ = attribute->getName();
        // get attribute data pointer
        // TODO: check types match
        // TODO: add the other types
 
        // int
        if constexpr (std::is_same<bt::intT, T>::value)
        {
            data_=attribute->intStore_;
        }
 
        // float
        else if constexpr (std::is_same<bt::floatT, T>::value)
        {
            data_=attribute->floatStore_;
        }
 
        // vector 3
        else if constexpr (std::is_same<enzo::bt::Vector3, T>::value)
        {
            data_=attribute->vector3Store_;
        }
        else if constexpr (std::is_same<enzo::bt::boolT, T>::value)
        {
            data_=attribute->boolStore_;
        }
        else if constexpr (std::is_same<enzo::bt::Matrix4, T>::value)
        {
            data_=attribute->matrix4Store_;
        }
        else
        {
                throw std::runtime_error("Type " + std::to_string(static_cast<int>(type_)) + " was not properly accounted for in AttributeHandle constructor");
        }
 
    }
 
    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];
    }
 
    std::string getName() const
    {
        return name_;
    }
 
 
 
private:
    // private attributes are attributes that are hidden from the user
    // for internal use
    bool private_=false;
    // hidden attributes are user accessible attributes that the user may
    // or may want to use
    bool hidden_=false;
    // allows the user to read the attributeHandle but not modify it
    bool readOnly_=false;
 
    std::string name_;
 
    std::shared_ptr<StoreContainer<T>> data_;
 
    // int typeID_;
 
};
 
using AttributeHandleInt = AttributeHandle<bt::intT>;
using AttributeHandleFloat = AttributeHandle<bt::floatT>;
using AttributeHandleVector3 = AttributeHandle<enzo::bt::Vector3>;
using AttributeHandleBool = AttributeHandle<enzo::bt::boolT>;
using AttributeHandleMatrix4 = AttributeHandle<enzo::bt::Matrix4>;
 
 
}