slim_delegate.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
 
namespace Arp
{
 
template <typename T> class slim_delegate;
 
// class slim_delegate is implemented completely implicite inline to avoid
// code bloat in commonly used Core classe and therefore reduce compile time
template<class R, class ...A>
class slim_delegate<R(A...)>
{
private: // typedefs/usings
    using InvokerPtr = R(*)(void*, A && ...);
 
public: // construction/destruction/assignment
    slim_delegate(const slim_delegate&) = default;
    slim_delegate(slim_delegate&&)noexcept = default;
    slim_delegate& operator=(const slim_delegate&) = default;
    slim_delegate& operator=(slim_delegate&&)noexcept = default;
 
public: // static factory operations
    template <R(*TFunction)(A...)>
    static slim_delegate create(void) noexcept
    {
        return{ functionInvoker<TFunction> };
    }
 
    template <class C, R(C::*TMethod)(A...)>
    static slim_delegate create(C* pObject) noexcept
    {
        return{ pObject, methodInvoker<C, TMethod> };
    }
 
    template <class C, R(C::*TMethod)(A...)>
    static slim_delegate create(C& obj) noexcept
    {
        return{ &obj, methodInvoker<C, TMethod> };
    }
 
    template <class C, R(C::*TMethod)(A...)const>
    static slim_delegate create(const C* pObject) noexcept
    {
        return{ const_cast<C*>(pObject), constMethodInvoker<C, TMethod> };
    }
 
    template <class C, R(C::*TMethod)(A...)const>
    static slim_delegate create(const C& obj) noexcept
    {
        return{ const_cast<C*>(&obj), constMethodInvoker<C, TMethod> };
    }
 
public: // operators
    bool operator==(const slim_delegate& rhs)const noexcept
    {
        if (this->is_static())
        {
            return this->pInvoker == rhs.pInvoker;
        }
        // else
        return (this->pInstance == rhs.pInstance) && (this->pInvoker == rhs.pInvoker);
    }
 
    bool operator!=(const slim_delegate& rhs)const noexcept
    {
        return !(operator==(rhs));
    }
 
public: // nullptr and bool support
    slim_delegate(std::nullptr_t) noexcept : slim_delegate(nullptr, nullptr) { }
 
    bool operator==(std::nullptr_t)const noexcept
    {
        if (this->is_static())
        {
            return this->pInvoker == nullptr;
        }
        // else
        return this->pInstance == nullptr || this->pInvoker == nullptr;
    }
 
    bool operator!=(std::nullptr_t)const noexcept
    {
        return !(*this == nullptr);
    }
 
    explicit operator bool()const noexcept
    {
        return *this != nullptr;
    }
 
public: // functor operator ()
    R operator()(A... args) const
    {
        return pInvoker(this->pInstance, std::forward<A>(args)...);
    }
 
private: // construction
    slim_delegate(InvokerPtr invokerPtr) noexcept
        : pInstance(this), pInvoker(invokerPtr) // set pInstance to this a make operator bool work correctly
    {
    }
 
    slim_delegate(void* pObject, InvokerPtr invokerPtr) noexcept
        : pInstance(pObject), pInvoker(invokerPtr)
    {
    }
 
    bool is_static(void)const
    {
        return this->pInstance == this;
    }
 
private: // invoker methods stored by pInvoker
    template <R(*TFunction)(A...)>
    static R functionInvoker(void* const, A&& ... args)
    {
        return TFunction(std::move(args)...);
    }
 
    template <class C, R(C::*TMethod)(A...)>
    static R methodInvoker(void* pObject, A&& ... args)
    {
        return (static_cast<C*>(pObject)->*TMethod)(std::move(args)...);
    }
 
    template <class C, R(C::*TMethod)(A...) const>
    static R constMethodInvoker(void* pObject, A&& ... args)
    {
        return (static_cast<const C*>(pObject)->*TMethod)(std::move(args)...);
    }
 
private: // fields
    void*       pInstance;
    InvokerPtr  pInvoker;
};
 
} // end of namespace Arp