mdframe.hpp

#ifndef NGEN_MDFRAME_DEFINITION_HPP
#define NGEN_MDFRAME_DEFINITION_HPP
 
#include <unordered_set>
#include <unordered_map>
 
#include "dimension.hpp"
#include "visitors.hpp"
#include "variable.hpp"
 
namespace ngen {
 
class mdframe {
  public:
    using dimension     = detail::dimension;
    using dimension_set = std::unordered_set<dimension, dimension::hash>;
    using variable      = detail::variable<int, float, double>;
    using variable_map  = std::unordered_map<std::string, variable>;
    using size_type     = variable::size_type;
 
    using types = variable::types;
 
    using mdarray_variant = variable::mdarray_variant;
 
    // ------------------------------------------------------------------------
    // Dimension Member Functions
    // ------------------------------------------------------------------------
    
  private:
    dimension_set::const_iterator find_dimension(const std::string& name) const noexcept
    {
        return this->m_dimensions.find(dimension(name));
    }
 
    variable_map::const_iterator find_variable(const std::string& name) const noexcept
    {
        return this->m_variables.find(name);
    }
 
  public:
    boost::optional<detail::dimension> get_dimension(const std::string& name) const noexcept
    {
        decltype(auto) pos = this->find_dimension(name);
 
        boost::optional<detail::dimension> result;
        if (pos != this->m_dimensions.end()) {
            result = *pos;
        }
 
        return result;
    }
 
    bool has_dimension(const std::string& name) const noexcept
    {
        return this->find_dimension(name) != this->m_dimensions.end();
    }
 
    mdframe& add_dimension(const std::string& name)
    {
        this->m_dimensions.emplace(name);
        return *this;
    }
 
    mdframe& add_dimension(const std::string& name, std::size_t size)
    {
        auto stat = this->m_dimensions.emplace(name, size);
 
        if (!stat.second) {
            stat.first->m_size = size;
        }
 
        return *this;
    }
 
    // ------------------------------------------------------------------------
    // Variable Member Functions
    // ------------------------------------------------------------------------
 
    variable& get_variable(const std::string& name) noexcept
    {
        return this->m_variables[name];
    }
 
    variable& operator[](const std::string& name) noexcept
    {
        return this->get_variable(name);
    }
 
    bool has_variable(const std::string& name) const noexcept
    {
       return this->find_variable(name) != this->m_variables.end();
    }
 
    template<typename T, types::enable_if_supports<T, bool> = true>
    mdframe& add_variable(const std::string& name, std::initializer_list<std::string> dimensions)
    {
        std::vector<dimension> references;
        references.reserve(dimensions.size());
 
        for (const auto& d : dimensions) {
            auto dopt = this->get_dimension(d);
            if (dopt == boost::none) {
                throw std::runtime_error("not a dimension");
            }
            references.push_back(dopt.get());
        }
 
        this->m_variables[name] = variable::make<T>(name, references);
    
        return *this;
    }
 
 
    // ------------------------------------------------------------------------
    // Output Member Functions
    // ------------------------------------------------------------------------
 
    void to_csv(const std::string& path, bool header = true) const;
 
    void to_netcdf(const std::string& path) const;
 
  private:
    dimension_set m_dimensions;
    variable_map  m_variables;
};
 
} // namespace ngen
 
#endif // NGEN_MDFRAME_DEFINITION_HPP