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

#pragma once

#include <cpphibernate/schema/schema.inl>

#include "table.h"

#include "table_simple.inl"
#include "table_polymorphic.inl"

namespace cpphibernate {
namespace mariadb {

    /* table_t */

    template<
        typename T_schema,
        typename T_table>
    table_t::table_t(
        const schema_t& p_owner,
        const T_schema& p_schema,
        const T_table&  p_table)
        : id        (hana::value(p_table.table_id))
        , dataset_id(get_type_id(p_table.wrapped_dataset))
        , name      (p_table.name)
        , schema    (p_owner)
        , fields    (make_fields(*this, p_schema, p_table))
        { }

    namespace __impl
    {

        /* table_builder */

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

        template<typename T_owner, typename T_schema, typename T_table>
        struct table_builder<
            mp::list<T_owner, T_schema, T_table>,
            mp::enable_if_t<
                    mp::is_same_v<schema_t, mp::decay_t<T_owner>>
                &&  schema::is_schema_v<mp::decay_t<T_schema>>
                &&  schema::is_table_v<mp::decay_t<T_table>>>>
        {

            /* table_type */

            template<
                typename T_dataset,
                typename T_base_dataset,
                typename T_derived_datasets,
                typename = void>
            struct table_type
                { using type = table_simple_t /* table_simple_t<mp::decay_t<T_schema>, mp::decay_t<T_table>, T_base_dataset> */; };

            template<
                typename T_dataset,
                typename T_base_dataset,
                typename T_derived_datasets>
            struct table_type<
                T_dataset,
                T_base_dataset,
                T_derived_datasets,
                mp::enable_if_t<
                        decltype(hana::size(std::declval<T_derived_datasets>()) != hana::size_c<0>)::value
                    ||  decltype(hana::not_equal(std::declval<T_base_dataset>(), hana::type_c<void>))::value>>
                { using type = table_polymorphic_t /* table_polymorphic_t<mp::decay_t<T_schema>, mp::decay_t<T_table>, T_base_dataset> */; };

            template<
                typename T_dataset,
                typename T_base_dataset,
                typename T_derived_datasets>
            using table_type_t = typename table_type<T_dataset, T_base_dataset, T_derived_datasets>::type;

            /* apply */

            static decltype(auto) apply(const schema_t& owner, const T_schema& schema, const T_table& table)
            {
                using dataset_type          = decltype(+table.wrapped_dataset);
                using base_dataset_type     = mp::decay_t<decltype(schema::get_base_type(schema, table.wrapped_dataset))>;
                using derived_datasets_type = mp::decay_t<decltype(schema::get_derived_types(schema, table.wrapped_dataset))>;
                using table_type            = table_type_t<dataset_type, base_dataset_type, derived_datasets_type>;

                return std::make_unique<table_type>(
                    owner, schema, table,
                    base_dataset_type { }, derived_datasets_type { });
            }

        };


    }

} }