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

#pragma once

#include "field_foreign_table.h"

#include "../../impl/create_update.inl"
#include "../../context/read_context.inl"
#include "../../context/create_update_context.inl"

namespace cpphibernate {
namespace mariadb {

    /* field_foreign_table_t */

    template<
        typename T_field>
    template<
        typename T_schema,
        typename T_table>
    field_foreign_table_t<T_field>::field_foreign_table_t(
        const table_t&  p_owner,
        const T_schema& p_schema,
        const T_table&  p_table,
        const T_field&  p_field)
        : field_simple_t<T_field>::field_simple_t(
            p_owner,
            p_schema,
            p_table,
            p_field)
        { }

    template<
        typename T_field>
    value_t field_foreign_table_t<T_field>
        ::foreign_create_update(const create_update_context& context) const
    {
        using dataset_type = typename decltype(+this->_field.wrapped_dataset_type)::type;

        auto& dataset       = context.get<dataset_type>();
        auto& foreign       = this->_field.getter(dataset);
        auto  next_context  = change_context(context, foreign);

        using foreign_dataset_type = mp::decay_t<decltype(foreign)>;
        return create_update_impl_t<foreign_dataset_type>::apply(
            next_context,
            false);
    }

    template<
        typename T_field>
    read_context_ptr_u field_foreign_table_t<T_field>
        ::foreign_read(const read_context& context, bool create_fake) const
    {
        using dataset_type = typename decltype(+this->_field.wrapped_dataset_type)::type;
        using value_type   = typename decltype(+this->_field.wrapped_value_type)::type;

        if (create_fake)
        {
            auto new_context = make_read_context(context.schema, context.connection, hana::type_c<value_type>, context.filter);
            using context_type = mp::decay_t<decltype(new_context)>;
            return std::make_unique<context_type>(std::move(new_context));
        }
        else
        {
            auto& dataset      = context.get<dataset_type>();
            auto& member       = this->_field.getter(dataset);
            auto  new_context  = make_read_context(context.schema, context.connection, member, context.filter);

            using context_type = mp::decay_t<decltype(new_context)>;
            return std::make_unique<context_type>(std::move(new_context));
        }
    }

} }