RMonoAPIFunction_Def.h

/*
    Copyright 2020 David "Alemarius Nexus" Lerch
 
    This file is part of RemoteMono.
 
    RemoteMono is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    RemoteMono is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with RemoteMono.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "../config.h"
 
#include <string>
#include "RMonoAPIFunctionTypeAdapters.h"
#include "RMonoAPIFunctionSimple_Def.h"
#include "RMonoAPIFunctionRaw_Def.h"
#include "RMonoAPIFunctionWrap_Def.h"
#include "RMonoAPIFunctionAPI_Def.h"
#include "RMonoAPIBase_Def.h"
 
 
 
namespace remotemono
{
 
 
 
 
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
class RMonoAPIFunctionBase :
        public RMonoAPIFunctionRaw<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>, ABI, RetT, ArgsT...>,
        public RMonoAPIFunctionWrap<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>, ABI, RetT, ArgsT...>,
        public RMonoAPIFunctionAPI<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>, ABI, RetT, ArgsT...>
{
public:
    typedef RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...> Self;
 
    typedef RetT DefRetType;
    typedef std::tuple<ArgsT...> DefArgsTuple;
 
public:
    constexpr static bool isRequired()
    {
        return required;
    }
 
public:
    RMonoAPIFunctionBase() : abi(nullptr), mono(nullptr) {}
 
    void reset()
    {
        resetRaw();
        resetWrap();
        resetAPI();
 
        abi = nullptr;
        mono = nullptr;
        name.clear();
    }
 
    void init(ABI* abi, RMonoAPIBase* mono, const std::string& name, blackbone::ptr_t rawFuncAddr)
    {
        this->abi = abi;
        this->mono = mono;
        this->name = name;
        this->initRaw(rawFuncAddr);
    }
 
    void initInvalid(const std::string& name)
    {
        this->name = name;
    }
 
    asmjit::Label compile(blackbone::IAsmHelper& a)
    {
        return this->compileWrap(a);
    }
 
    void link(blackbone::ptr_t wrapFuncAddr)
    {
        this->linkWrap(wrapFuncAddr);
    }
 
    void debugDumpSignatures();
 
    ABI* getABI() { return abi; }
 
    RMonoAPIBase* getRemoteMonoAPI() { return mono; }
 
    std::string getName() const { return name; }
 
    operator bool() const { return (bool) rawFunc; }
 
private:
    template <typename ArgsTupleT, size_t argIdx>
    void debugDumpSignaturesArgRecurse(std::string& sigStr);
 
private:
    ABI* abi;
    RMonoAPIBase* mono;
    std::string name;
};
 
 
 
 
 
// These methods can be used to access types defined in the component classes without the umbrella class having been fully defined yet.
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
struct RMonoAPIFunctionCommonTraits<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>>
{
    typedef RetT DefRetType;
    typedef std::tuple<ArgsT...> DefArgsTuple;
};
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
struct RMonoAPIFunctionRawTraits<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>>
{
    typedef RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...> CommonType;
 
    typedef RMonoAPIFunctionRaw<CommonType, ABI, RetT, ArgsT...> RawComponent;
 
    typedef typename RawComponent::RawRetType RawRetType;
    typedef typename RawComponent::RawArgsTuple RawArgsTuple;
};
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
struct RMonoAPIFunctionWrapTraits<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>>
{
    typedef RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...> CommonType;
 
    typedef RMonoAPIFunctionWrap<CommonType, ABI, RetT, ArgsT...> WrapComponent;
 
    typedef typename WrapComponent::WrapRetType WrapRetType;
    typedef typename WrapComponent::WrapArgsTuple WrapArgsTuple;
};
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
struct RMonoAPIFunctionAPITraits<RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...>>
{
    typedef RMonoAPIFunctionBase<ABI, required, RetT, ArgsT...> CommonType;
 
    typedef RMonoAPIFunctionAPI<CommonType, ABI, RetT, ArgsT...> APIComponent;
 
    typedef typename APIComponent::APIRetType APIRetType;
    typedef typename APIComponent::APIArgsTuple APIArgsTuple;
};
 
 
 
 
 
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
class RMonoAPIFunctionAutoAddNullTags : public RMonoAPIFunctionBase <
        ABI,
        required,
        typename tags::ReturnNull<RetT>,
        typename tags::ParamNull<ArgsT>...
        > {};
 
 
template <typename ABI, bool required, typename RetT, typename... ArgsT>
using RMonoAPIFunction = RMonoAPIFunctionAutoAddNullTags<ABI, required, RetT, ArgsT...>;
 
 
 
}