variable.hpp

#ifndef NGEN_IO_MDFRAME_VARIABLE_HPP
#define NGEN_IO_MDFRAME_VARIABLE_HPP
 
#include "mdarray.hpp"
#include "traits.hpp"
#include "dimension.hpp"
#include <initializer_list>
#include <functional>
 
#include "visitors.hpp"
 
namespace ngen {
 
namespace detail {
 
template<typename... SupportedTypes>
struct variable {
    using size_type = std::size_t;
 
    using types = traits::type_list<SupportedTypes...>;
 
    using mdarray_variant = typename types::template variant_container<ngen::mdarray>;
 
    using element_type = typename types::variant_scalar;
 
    // Hasher for variables
    struct hash
    {
        std::size_t operator()(const variable& v) const noexcept
        {
            return std::hash<std::string>{}(v.m_name);
        }
 
        static std::size_t apply(const variable& d) noexcept
        {
            return variable::hash{}(d);
        }
    };
 
    variable() noexcept
        : m_name()
        , m_data()
        , m_dimensions() {};
 
    template<typename T, typename types::template enable_if_supports<T, bool> = true>
    static variable make(const std::string& name, const std::vector<dimension>& dimensions)
    {
        variable var;
        var.m_name = name;
        var.m_dimensions = dimensions;
 
        std::vector<size_type> dsizes;
        dsizes.reserve(dimensions.size());
        for (const auto& d : dimensions) {
            dsizes.push_back(d.size());
        }
    
        var.m_data = mdarray<T>{dsizes};
        return var;
    }
 
    template<typename T, typename types::template enable_if_supports<T, bool> = true>
    variable& set_data(const mdarray<T>& data)
    {
        this->m_data = data;
    }
 
    template<typename T, typename types::template enable_if_supports<T, bool> = true>
    variable& set_data(mdarray<T>&& data)
    {
        this->m_data = std::move(data);
    }
 
    const mdarray_variant& values() const noexcept
    {
        return this->m_data;
    }
 
    template<typename T, typename types::template enable_if_supports<T, bool> = true>
    const mdarray<T>& values() const noexcept
    {
        return boost::get<mdarray<T>>(this->m_data);
    }
 
    bool operator==(const variable& rhs) const
    {
        return this->m_name == rhs.m_name;
    }
 
    const std::string& name() const noexcept {
        return this->m_name;
    }
 
    std::vector<std::string> dimensions() const noexcept {
        std::vector<std::string> names;
        names.reserve(this->m_dimensions.size());
        for (const dimension& dim : this->m_dimensions) {
            names.push_back(dim.name());
        }
 
        return names;
    }
 
    size_type size() const noexcept {
        return boost::apply_visitor(visitors::mdarray_size{}, this->m_data);
    }
 
    size_type rank() const noexcept {
        return boost::apply_visitor(visitors::mdarray_rank{}, this->m_data);
    }
 
    template<typename T, typename types::template enable_if_supports<T, bool> = true>
    void insert(boost::span<const size_type> index, T value)
    {
        // bind arguments to operator()
        auto visitor = std::bind(
            visitors::mdarray_insert{},
            std::placeholders::_1,
            index,
            value
        );
 
        boost::apply_visitor(visitor, this->m_data);
    }
 
    element_type at(const boost::span<const size_type> index)
    {
        auto visitor = std::bind(
            visitors::mdarray_at<SupportedTypes...>{},
            std::placeholders::_1,
            index
        );
    
        return boost::apply_visitor(visitor, this->m_data);
    }
 
    template<typename T, typename types::template enable_if_supports<T, bool> = true>
    T at(boost::span<const size_type> index)
    {
        auto visitor = std::bind(
            visitors::mdarray_at<SupportedTypes...>{},
            std::placeholders::_1,
            index
        );
 
        element_type result = boost::apply_visitor(visitor, this->m_data);
        T value = boost::get<T>(result);
        return value;
    }
 
    boost::span<const size_type> shape() const noexcept
    {
        return boost::apply_visitor(visitors::mdarray_shape{}, this->m_data);
    }
 
  private:
    // Name of this variable
    mutable std::string m_name;
 
    // multi-dimensional vector associated with this variable
    mdarray_variant m_data;
 
    // References to dimensions that this variable spans
    std::vector<dimension> m_dimensions;
};
 
} // namespace detail
 
} // namespace ngen
 
#endif // NGEN_IO_MDFRAME_VARIABLE_HPP