soa.hpp

Go to the documentation of this file.

#ifndef CODEX_REFLECTION_SOA_HPP
#define CODEX_REFLECTION_SOA_HPP
 
#include <span>
 
#include "detail/soa.hpp"
#include "fields.hpp"
 
namespace codex::refl {
 
template<typename T, typename S = detail::storage_descriptor>
class SOA : detail::storage<T, S> {
    using base_type = detail::storage<T, S>;
public:
    // Should be `base_type::value_type`, but that generates an ICE(!?).
    template<std::size_t I>
    using field_type =
        std::decay_t<std::tuple_element_t<I, field_tuple_t<T>>>;
    // Container interface.
    std::size_t size(void) const { return this->field<0>().size(); }
    void push_back(T &&t = {});
    // Idiosyncratic container interface.
    T operator[](std::size_t i) const;
    void set(std::size_t i, const T &t);
    void set(std::size_t i, T &&t);
    template<std::size_t I> std::span<field_type<I>> field(void);
    template<std::size_t I> std::span<const field_type<I>> field(void) const;
};
 
template<typename T, typename S>
T SOA<T, S>::operator[](std::size_t i) const {
    T ret = {};
    this->for_each_i(i, [t = field_tuple(ret)](auto fi, auto &x) {
        std::get<fi()>(t) = x;
    });
    return ret;
}
 
template<typename T, typename S>
void SOA<T, S>::push_back(T &&t) {
    using detail::field_storage;
    this->for_each([&t]<typename F, std::size_t I>(field_storage<S, I, F> &v) {
        v.push_back(std::get<I>(field_tuple(CODEX_FWD(t))));
    });
}
 
template<typename T, typename S>
void SOA<T, S>::set(std::size_t i, const T &t) {
    this->for_each_i(i, [&t](auto vi, auto &x) {
        x = std::get<vi()>(field_tuple(t));
    });
}
 
template<typename T, typename S>
void SOA<T, S>::set(std::size_t i, T &&t) {
    this->for_each_i(i, [&t](auto vi, auto &x) {
        x = std::get<vi()>(field_tuple(std::move(t)));
    });
}
 
template<typename T, typename S>
template<std::size_t I>
auto SOA<T, S>::field(void) -> std::span<field_type<I>> {
    using F = field_type<I>;
    return *static_cast<detail::field_storage<S, I, F>*>(this);
}
 
template<typename T, typename S>
template<std::size_t I>
auto SOA<T, S>::field(void) const -> std::span<const field_type<I>> {
    using F = field_type<I>;
    return *static_cast<const detail::field_storage<S, I, F>*>(this);
}
 
}
 
#endif