cpphibernate/include/cpphibernate/driver/mariadb/classes/tables/tables.inl

#pragma once

#include "tables.h"

#include "table.inl"

namespace cpphibernate {
namespace mariadb {

    namespace __impl
    {

        /* tables_builder */

        template<typename X, typename>
        struct tables_builder
        {
            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&... args)
                { static_assert(sizeof...(args) == -1, "Invalid parameters for mariadb::make_tables(...)!"); }
        };

        template<
            typename T_owner,
            typename T_schema>
        struct tables_builder<
            mp::list<T_owner, T_schema>,
            mp::enable_if_t<
                    mp::is_same_v<schema_t, mp::decay_t<T_owner>>
                &&  schema::is_schema_v<mp::decay_t<T_schema>>>>
        {
            template<typename T_index>
            static constexpr void emplace(
                tables_t&       result,
                const schema_t& owner,
                const T_schema& schema,
                T_index&&       index)
            {
                result.emplace_back(make_table(owner, schema, schema.tables[index]));
            }

            template<size_t... I>
            static decltype(auto) helper(
                const schema_t& owner,
                const T_schema& schema,
                std::index_sequence<I...> seq)
            {
                tables_t ret;
                ret.reserve(sizeof...(I));
                int dummy[] = { 0, (emplace(ret, owner, schema, hana::size_c<I>), void(), 0)... };
                (void) dummy;
                return ret;
            }

            static constexpr decltype(auto) apply(
                const schema_t& owner,
                const T_schema& schema)
            {
                using size = decltype(hana::size(schema.tables));
                return helper(owner, schema, std::make_index_sequence<size::value> { });
            }
        };

    }

} }