requestDispatcher.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_REQUESTDISPATCHER_HPP
#define RTCTK_COMPONENTFRAMEWORK_REQUESTDISPATCHER_HPP
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/config.hpp>
 
#include <any>
#include <functional>
#include <initializer_list>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace rtctk::componentFramework {
 
template <class Adapter, typename... Args>
class RTCTK_API RequestDispatcher final {
public:
    using DispatchFunction = std::function<void(Adapter*, std::any&, Args... args)>;
    using LookupTable = std::unordered_map<std::type_index, DispatchFunction>;
    using TableEntry = typename LookupTable::value_type;
 
    class RTCTK_API TableEntries final : public std::vector<TableEntry> {
    public:
        using std::vector<TableEntry>::vector;
 
        TableEntries& operator+=(const TableEntries& rhs) {
            TableEntries rhs_copy(rhs);
            return this->operator+=(std::move(rhs_copy));
        }
 
        TableEntries& operator+=(TableEntries&& rhs) {
            for (auto&& entry : std::forward<TableEntries>(rhs)) {
                this->emplace_back(std::move(entry));
            }
            return *this;
        }
 
        TableEntries operator+(const TableEntries& rhs) const {
            TableEntries rhs_copy(rhs);
            return this->operator+(std::move(rhs_copy));
        }
 
        TableEntries operator+(TableEntries&& rhs) const {
            TableEntries result;
            result += *this;
            result += std::forward<TableEntries>(rhs);
            return result;
        }
    };
 
    template <typename T>
    static TableEntries Bind(void (Adapter::*method)(T&, Args...)) {
        std::type_index type = typeid(T);
        DispatchFunction function = [method](Adapter* adapter, std::any& request, Args... args) {
            std::invoke(method, adapter, std::any_cast<T&>(request), std::forward<Args>(args)...);
        };
        return {{type, std::move(function)}};
    }
 
    RequestDispatcher() = default;
    RequestDispatcher(const RequestDispatcher& rhs) = default;
    RequestDispatcher(RequestDispatcher&& rhs) noexcept = default;
    ~RequestDispatcher() = default;
    RequestDispatcher& operator=(const RequestDispatcher& rhs) = default;
    RequestDispatcher& operator=(RequestDispatcher&& rhs) noexcept = default;
 
    RequestDispatcher(std::initializer_list<TableEntries> table_entries) {
        for (const auto& entry_list : table_entries) {
            for (const auto& entry : entry_list) {
                m_lut.emplace(entry);
            }
        }
    }
 
    void Dispatch(Adapter* adapter, std::any& request, Args... args) const {
        auto iter = m_lut.find(request.type());
        if (iter == m_lut.end()) {
            throw CII_MAKE_EXCEPTION(UnsupportedTypeException, request.type());
        }
        auto function = iter->second;
        function(adapter, request, std::forward<Args>(args)...);
    }
 
    RequestDispatcher& operator+=(const RequestDispatcher& rhs) {
        RequestDispatcher rhs_copy(rhs);
        return this->operator+=(std::move(rhs_copy));
    }
 
    RequestDispatcher& operator+=(RequestDispatcher&& rhs) {
        m_lut.merge(std::forward<LookupTable>(rhs.m_lut));
        return *this;
    }
 
    RequestDispatcher operator+(const RequestDispatcher& rhs) const {
        RequestDispatcher rhs_copy(rhs);
        return this->operator+(std::move(rhs_copy));
    }
 
    RequestDispatcher operator+(RequestDispatcher&& rhs) const {
        RequestDispatcher result;
        result += *this;
        result += rhs;
        return result;
    }
 
private:
    LookupTable m_lut;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_REQUESTDISPATCHER_HPP