cpphibernate/include/cpphibernate/driver/mariadb/classes/fields/field.inl

#pragma once

#include "field.h"

#include <cpphibernate/schema/schema.h>
#include <cpphibernate/misc/type_helper.h>

namespace cpphibernate {
namespace mariadb {

    template<
        typename T_schema,
        typename T_table,
        typename T_field>
    field_t::field_t(
        const table_t&  p_owner,
        const T_schema& p_schema,
        const T_table&  p_table,
        const T_field&  p_field)
        : id                        (get_type_id(hana::type_c<mp::decay_t<T_field>>))
        , value_id                  (get_type_id(hana::type_c<typename T_field::value_type>))
        , real_value_id             (get_type_id(hana::type_c<real_dataset_t<typename T_field::value_type>>))
        , value_is_nullable         (is_nullable_v <typename T_field::value_type>)
        , value_is_pointer          (is_pointer_v  <typename T_field::value_type>)
        , value_is_container        (is_container_v<typename T_field::value_type>)
        , value_is_ordered          (is_ordered_v  <typename T_field::value_type>)
        , value_is_auto_incremented (false)
        , table                     (p_owner)
        , referenced_table          (nullptr)
        , name                      (p_field.name)
        , type                      ()
        , create_arguments          ()
        , convert_to_open           ()
        , convert_to_close          ()
        , convert_from_open         ()
        , convert_from_close        ()
        , attributes                (make_attributes(p_field.attributes))
        { }

    namespace __impl
    {

        /* field_builder */

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

        template<typename T_owner, typename T_schema, typename T_table, typename T_field>
        struct field_builder<
            mp::list<T_owner, T_schema, T_table, T_field>,
            mp::enable_if_t<
                    mp::is_base_of_v<table_t, mp::decay_t<T_owner>>
                &&  schema::is_schema_v<mp::decay_t<T_schema>>
                &&  schema::is_table_v<mp::decay_t<T_table>>
                &&  schema::is_field_v<mp::decay_t<T_field>>>>
        {

            /* is_primary_key_field */

            template<typename X_field>
            struct is_primary_key_field
                : public decltype(
                    hana::contains(
                        std::declval<mp::decay_t<X_field>>().attributes,
                        schema::attribute::primary_key))
                { };

            /* is_foreign_table_field */

            template<typename X_schema, typename X_field>
            struct is_foreign_table_field
                : public decltype(
                    hana::contains(
                        hana::transform(
                            std::declval<X_schema>().tables,
                            schema::get_wrapped_dataset),
                        std::declval<X_field>().wrapped_real_value_type))
                { };

            /* field_type */

            template<typename X_schema, typename X_field, typename = void>
            struct field_type
                { using type = field_data_t<T_field>; };

            template<typename X_schema, typename X_field>
            struct field_type<
                X_schema,
                X_field,
                mp::enable_if_t<is_primary_key_field<X_field>::value>>
                { using type = field_primary_key_t<X_field>; };

            template<typename X_schema, typename X_field>
            struct field_type<
                X_schema,
                X_field,
                mp::enable_if_t<is_foreign_table_field<X_schema, X_field>::value>>
                { using type = field_foreign_table_t<X_field>; };

            template<typename X_schema, typename X_field>
            using field_type_t = typename field_type<X_schema, X_field>::type;

            /* apply */

            static constexpr decltype(auto) apply(const table_t& owner, const T_schema& schema, const T_table& table, const T_field& field)
            {
                using schema_type = mp::decay_t<T_schema>;
                using field_type  = mp::decay_t<T_field>;
                using return_type = field_type_t<schema_type, field_type>;

                return std::make_unique<return_type>(owner, schema, table, field);
            }
        };

    }

} }