cpphibernate/include/cpphibernate/context/context.inl

#pragma once

#include "context.h"

namespace cpphibernate
{

    namespace __impl
    {

        /* init_builder */

        template<typename X, typename = void>
        struct init_builder
        {
            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&...)
                { static_assert(sizeof...(T_args) == -1, "Invalid parameters for context::init(...)!"); }
        };

        template<typename T_impl, typename T_bool>
        struct init_builder<
            mp::list<T_impl, T_bool>,
            mp::enable_if_t<
                    mp::is_valid_v<decltype(std::declval<T_impl>().init(std::declval<bool>()))>
                &&  mp::is_same_v<bool, mp::decay_t<T_bool>>>>
        {
            static constexpr decltype(auto) apply(T_impl& impl, bool recreate)
                { return impl.init(recreate); }
        };

        constexpr decltype(auto) init = mp::generic_predicate<init_builder> { };

        /* create_builder */

        template<typename X, typename = void>
        struct create_builder
        {
            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&...)
                { static_assert(sizeof...(T_args) == -1, "Invalid parameters for context::create(...)!"); }
        };

        template<typename T_impl, typename T_dataset>
        struct create_builder<
            mp::list<T_impl, T_dataset>,
            mp::enable_if_t<
                mp::is_valid_v<decltype(std::declval<T_impl>().create(std::declval<T_dataset&>()))>>>
        {
            static constexpr decltype(auto) apply(T_impl& impl, T_dataset& dataset)
                { return impl.create(dataset); }
        };

        constexpr decltype(auto) create = mp::generic_predicate<create_builder> { };

        /* read_builder */

        template<typename X, typename = void>
        struct read_builder
        {
            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&...)
                { static_assert(sizeof...(T_args) == -1, "Invalid parameters for context::read(...)!"); }
        };

        constexpr decltype(auto) read = mp::generic_predicate<read_builder> { };
#if 0
        template<typename T_impl, typename T_dataset, typename... T_modifiers>
        struct create_impl<
            mp::list<T_impl, T_dataset, T_modifiers...>,
            mp::enable_if_t<mp::is_true_v<is_modifier_v<mp::decay_t<T_modifiers>>...>>>
        {
            static constexpr decltype(auto) apply(T_impl& impl, T_dataset& dataset, T_modifiers&&... modifiers)
                { return impl.read(dataset, make_modifiers(std::forward<T_modifiers>(modifiers)...)); }
        };
#endif
        /* update_builder */

        template<typename X, typename = void>
        struct update_builder
        {
            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&...)
                { static_assert(sizeof...(T_args) == -1, "Invalid parameters for context::update(...)!"); }
        };

        constexpr decltype(auto) update = mp::generic_predicate<update_builder> { };
#if 0
        template<typename T_impl, typename T_dataset>
        struct update_impl<mp::list<T_impl, T_dataset>, void>
        {
            static constexpr decltype(auto) apply(T_impl& impl, T_dataset& dataset)
                { return impl.update(dataset); }
        };
#endif
        /* destroy_builder */

        template<typename X, typename = void>
        struct destroy_builder
        {
            template<typename... T_args>
            static constexpr decltype(auto) apply(T_args&&...)
                { static_assert(sizeof...(T_args) == -1, "Invalid parameters for context::destroy(...)!"); }
        };

        constexpr decltype(auto) destroy = mp::generic_predicate<destroy_builder> { };
#if 0
        template<typename T_impl, typename T_dataset>
        struct destroy_impl<mp::list<T_impl, T_dataset>, void>
        {
            static constexpr decltype(auto) apply(T_impl& impl, T_dataset& dataset)
                { return impl.create(dataset); }
        };
#endif

    }

    /* context */

    template<typename T_driver, typename T_schema>
    template<typename... T_args>
    constexpr context<T_driver, T_schema>::context(const schema_type& p_schema, T_args&&... p_args)
        : base_type (p_schema, std::forward<T_args>(p_args)...)
        , _schema   (p_schema)
        { }

    template<typename T_driver, typename T_schema>
    template<typename... T_args>
    constexpr decltype(auto) context<T_driver, T_schema>::init(T_args&&... args)
        { return __impl::init(this->impl(), std::forward<T_args>(args)...); }

    template<typename T_driver, typename T_schema>
    template<typename... T_args>
    constexpr decltype(auto) context<T_driver, T_schema>::create(T_args&&... args)
        { return __impl::create(this->impl(), std::forward<T_args>(args)...); }

    template<typename T_driver, typename T_schema>
    template<typename... T_args>
    constexpr decltype(auto) context<T_driver, T_schema>::read(T_args&&... args)
        { return __impl::read(this->impl(), std::forward<T_args>(args)...); }

    template<typename T_driver, typename T_schema>
    template<typename... T_args>
    constexpr decltype(auto) context<T_driver, T_schema>::update(T_args&&... args)
        { return __impl::update(this->impl(), std::forward<T_args>(args)...); }

    template<typename T_driver, typename T_schema>
    template<typename... T_args>
    constexpr decltype(auto) context<T_driver, T_schema>::destroy(T_args&&... args)
        { return __impl::destroy(this->impl(), std::forward<T_args>(args)...); }


#if 0
        template<typename T_dataset, typename... T_modifiers>
        constexpr auto read(T_dataset& dataset, T_modifiers&&... modifiers)
            -> mp::enable_if<
                modifier::all_are_modifiers<mp::decay_t<T_modifiers>...>>
        {
            using namespace modifier;
            using real_dataset_type = misc::real_dataset_t<mp::decay_t<T_dataset>>;
            schema::tables::find(_schema.tables, hana::type_c<real_dataset_type>);
            this->read_impl(dataset, modifier::make_list(std::forward<T_modifiers>(modifiers)...));
        }

        template<typename T_dataset>
        constexpr auto read(T_dataset& dataset)
            -> mp::enable_if_c<
                    !misc::is_container<mp::decay_t<T_dataset>>::value
                && !misc::is_nullable<mp::decay_t<T_dataset>>::value>
        {
            using namespace modifier;
            using real_dataset_type = misc::real_dataset_t<mp::decay_t<T_dataset>>;
            auto& table         = schema::tables::find(_schema.tables, hana::type_c<real_dataset_type>);
            auto& primary_key   = schema::table::get_primary_key_field(table);
            this->read_impl(dataset, modifier::make_list(where(equal(primary_key, primary_key.getter(dataset)))));
        }

        template<typename T_dataset>
        constexpr auto read(T_dataset& dataset)
            -> mp::enable_if_c<
                    misc::is_container<mp::decay_t<T_dataset>>::value
                ||  misc::is_nullable<mp::decay_t<T_dataset>>::value>
        {
            using namespace modifier;
            using real_dataset_type = misc::real_dataset_t<mp::decay_t<T_dataset>>;
            schema::tables::find(_schema.tables, hana::type_c<real_dataset_type>);
            this->read_impl(dataset, modifier::make_list());
        }
#endif

    /* make_context */

    template<typename T_driver, typename T_schema, typename... T_args>
    constexpr decltype(auto) make_context(T_schema&& schema, T_args&&... args)
    {
        using context_type = context<T_driver, T_schema>;
        return context_type(std::forward<T_schema>(schema), std::forward<T_args>(args)...);
    }

    /* make_context_ptr */

    template<typename T_driver, typename T_schema, typename... T_args>
    constexpr decltype(auto) make_context_ptr(T_schema&& schema, T_args&&... args)
    {
        using context_type = context<T_driver, T_schema>;
        using pointer_type = std::unique_ptr<context_type>;
        return pointer_type(new context_type(std::forward<T_schema>(schema), std::forward<T_args>(args)...));
    }

}