RMonoAPIDispatcher_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 <tuple>
#include <type_traits>
#include <cstdlib>
#include "abi/RMonoABI.h"
#include "RMonoAPIBackend_Def.h"
 
 
 
 
namespace remotemono
{
 
 
 
class RMonoAPIDispatcherBase
{
public:
    template <typename ABI>
    struct ABIEntry
    {
        typedef ABI ABIType;
 
        ABIEntry() : api(&abi) {}
 
        ABI abi;
 
        RMonoAPIBackend<ABI> api;
    };
 
protected:
    static auto genABIEntryTupleDummy()
    {
        return std::apply([](auto... ts) {
            return std::tuple<ABIEntry<decltype(ts)>...>();
        }, RMonoSupportedABITuple());
    }
};
 
 
 
class RMonoAPIDispatcher : public RMonoAPIDispatcherBase
{
public:
    typedef decltype(RMonoAPIDispatcherBase::genABIEntryTupleDummy()) ABIEntryTuple;
 
public:
    RMonoAPIDispatcher() : selectedABIIdx(std::tuple_size_v<ABIEntryTuple>) {}
    ~RMonoAPIDispatcher() {}
 
    ABIEntryTuple& getABIEntries() { return abis; }
 
 
    bool hasSelectedABI() const
    {
        return selectedABIIdx < std::tuple_size_v<ABIEntryTuple>;
    }
 
    template <typename ABI>
    void selectABI()
    {
        selectedABIIdx = abiIndexOf<ABI>();
    }
 
 
    template <typename FuncT, size_t idx = 0>
    typename std::enable_if_t<idx < std::tuple_size_v<ABIEntryTuple>, void> foreach(FuncT f)
    {
        f(std::get<idx>(abis));
        foreach<FuncT, idx+1>(f);
    }
 
    template <typename FuncT, size_t idx = 0>
    typename std::enable_if_t<idx == std::tuple_size_v<ABIEntryTuple>, void> foreach(FuncT f) {}
 
 
 
    template <typename FuncT>
    auto apply(FuncT f) -> decltype(applyInternal<FuncT, 0>(f))
    {
        return applyInternal<FuncT, 0>(f);
    }
 
private:
    template<typename ABI, size_t idx = 0>
    constexpr std::enable_if_t<idx < std::tuple_size_v<ABIEntryTuple>, size_t> abiIndexOf()
    {
        if constexpr(std::is_same_v<typename std::tuple_element_t<idx, ABIEntryTuple>::ABIType, ABI>) {
            return idx;
        } else {
            return abiIndexOf<ABI, idx+1>();
        }
    }
 
    template<typename ABI, size_t idx = 0>
    constexpr std::enable_if_t<idx == std::tuple_size_v<ABIEntryTuple>, size_t> abiIndexOf() { static_assert(false); return 0; }
 
    template <typename FuncT, size_t idx>
    auto applyInternal(FuncT f) -> decltype(f(std::get<0>(abis)))
    {
        if constexpr(idx < std::tuple_size_v<ABIEntryTuple>) {
            if (idx == selectedABIIdx) {
                return f(std::get<idx>(abis));
            } else {
                return applyInternal<FuncT, idx+1>(f);
            }
        } else {
            assert(false);
            return f(std::get<0>(abis)); // Should never happen, but needed to please the compiler
        }
    }
 
 
private:
    ABIEntryTuple abis;
    size_t selectedABIIdx;
};
 
 
 
}