module_negotiator.hxx

Go to the documentation of this file.

 
#pragma once
#include <ice/module_concepts.hxx>
#include <ice/module_info.hxx>
#include <ice/module_query.hxx>
 
namespace ice
{
 
    using ice::concepts::ModuleNegotiator;

    struct ModuleNegotiatorAPI
    {
        using FnModuleInAppContext = bool(*)(
            ice::ModuleNegotiatorAPIContext*
        ) noexcept;

        using FnModuleSelectAPIs = bool (*)(
            ice::ModuleNegotiatorAPIContext*,
            ice::StringID_Hash api_name,
            ice::u32 api_version,
            ice::ModuleAPI* out_array,
            ice::u32* inout_array_size
        ) noexcept;

        using FnModuleRegisterAPI = bool (*)(
            ice::ModuleNegotiatorAPIContext*,
            ice::StringID_Hash api_name,
            ice::FnModuleSelectAPI* fn_api_selector
        ) noexcept;
 
        FnModuleInAppContext fn_is_app_context;
        FnModuleSelectAPIs fn_select_apis;
        FnModuleRegisterAPI fn_register_api;
    };

    class ModuleNegotiatorBase : public ice::ModuleQuery
    {
    public:
        ModuleNegotiatorBase(
            ice::ModuleNegotiatorAPI* negotiator_api,
            ice::ModuleNegotiatorAPIContext* negotiator_context
        ) noexcept;

        bool from_app() const noexcept;

        bool query_apis(
            ice::StringID_Arg api_name,
            ice::u32 api_version,
            ice::ModuleAPI* out_array,
            ice::u32* inout_array_size
        ) const noexcept override;

        bool register_api(
            ice::StringID_Arg api_name,
            ice::FnModuleSelectAPI* fn_api_selector
        ) const noexcept;
 
    public:
        ice::ModuleNegotiatorAPI* negotiator_api;
        ice::ModuleNegotiatorAPIContext* negotiator_context;
    };
 
    template<typename Tag>
    class ModuleNegotiatorTagged final : public ice::ModuleNegotiatorBase
    {
    public:
        using ModuleNegotiatorBase::ModuleNegotiatorBase;
        using ModuleNegotiatorBase::query_apis;
        using ModuleNegotiatorBase::register_api;

        template<typename T> requires(ice::concepts::APIType<T>)
        bool register_api(ice::ProcAPIQuickRegisterFunc<T> register_func) const noexcept;
    };
 
    inline ModuleNegotiatorBase::ModuleNegotiatorBase(
        ice::ModuleNegotiatorAPI* negotiator_api,
        ice::ModuleNegotiatorAPIContext* negotiator_context
    ) noexcept
        : negotiator_api{ negotiator_api }
        , negotiator_context{ negotiator_context }
    { }
 
    template<typename Tag>
    template<typename T> requires(ice::concepts::APIType<T>)
    inline bool ModuleNegotiatorTagged<Tag>::register_api(ice::ProcAPIQuickRegisterFunc<T> register_func) const noexcept
    {
        static T api_struct = [](ice::ProcAPIQuickRegisterFunc<T> func) noexcept
        {
            T result_struct;
            func(result_struct);
            return result_struct;
        }(register_func);
 
        return register_api(
            T::Constant_APIName,
            [](ice::StringID_Hash name, ice::u32 version, ice::ModuleAPI* api_ptr) noexcept -> bool
            {
                if (name == T::Constant_APIName && version == T::Constant_APIVersion)
                {
                    api_ptr->api_ptr = &api_struct;
                    api_ptr->version = T::Constant_APIVersion;
                    if constexpr (ice::concepts::APIExplicitPriority<T>)
                    {
                        api_ptr->priority = T::Constant_APIPriority;
                    }
                    else
                    {
                        api_ptr->priority = 100;
                    }
                    return true;
                }
                return false;
            }
        );
    }
 
} // namespace ice