soa.hpp

Go to the documentation of this file.

#ifndef CODEX_REFLECTION_SOA_DETAIL_HPP
#define CODEX_REFLECTION_SOA_DETAIL_HPP
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <vector>
 
#include "../fields.hpp"
#include "utils.hpp"
 
namespace codex::refl::detail {
 
template<typename S, std::size_t I, typename T>
class field_storage : public S::for_field<I, T> {
protected:
    static constexpr auto index = I;
};
 
template<typename S, typename Is, typename Ts> struct storage_impl;
 
template<typename S, std::size_t ...Is, typename ...Ts>
class storage_impl<S, std::index_sequence<Is...>, std::tuple<Ts...>>
    : public field_storage<S, Is, std::decay_t<Ts>>...
{
private:
    using tuple_type = std::tuple<std::decay_t<Ts>...>;
    template<std::size_t I>
    using value_type = std::tuple_element_t<I, tuple_type>;
    template<std::size_t I>
    using field_storage_type = field_storage<S, I, std::decay_t<value_type<I>>>;
public:
    template<std::size_t I>
    auto field(void) -> field_storage_type<I>& { return *this; }
    template<std::size_t I>
    auto field(void) const -> const field_storage_type<I>& { return *this; }
    void for_each(auto &&f) { (..., CODEX_FWD(f)(this->field<Is>())); }
    void for_each(auto &&f) const { (..., CODEX_FWD(f)(this->field<Is>())); }
    void for_each_i(std::size_t i, auto &&f);
    void for_each_i(std::size_t i, auto &&f) const;
};
 
template<typename S, std::size_t ...Is, typename ...Ts>
void storage_impl<
    S, std::index_sequence<Is...>, std::tuple<Ts...>
>::for_each_i(std::size_t i, auto &&f) {
    return this->for_each([i, &f]<typename V>(V &v) {
        CODEX_FWD(f)(index_constant<V::index>{}, v[i]);
    });
}
 
template<typename S, std::size_t ...Is, typename ...Ts>
void storage_impl<
    S, std::index_sequence<Is...>, std::tuple<Ts...>
>::for_each_i(std::size_t i, auto &&f) const {
    return this->for_each([i, &f]<typename V>(V &v) {
        CODEX_FWD(f)(index_constant<V::index>{}, v[i]);
    });
}
 
template<typename T, typename S>
using storage = storage_impl<
    S, std::make_index_sequence<refl::field_count<T>()>,
    refl::field_tuple_t<T>>;
 
struct storage_descriptor {
    template<std::size_t, typename T> using for_field = std::vector<T>;
};
 
}
 
#endif