ConstMethodFunctor.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Impl/DelegateFunctorBase.hxx"
 
namespace Arp { namespace System { namespace Core { namespace Impl
{
 
template <typename T> class ConstMethodFunctor;
 
// class MethodFunctor is implemented completely implicite inline to avoid
// code bloat in commonly used Core classe and therefore reduce compile time
template<class C, class R, class ...A>
class ConstMethodFunctor<R(C::*)(A...)const> : public DelegateFunctorBase<ConstMethodFunctor<R(C::*)(A...)const>>
{
public: // typedefs/usings
    using MethodPtr = R(C::*)(A...)const;
 
public: // construction/destruction
    ConstMethodFunctor(const C* pObjectArg, R(C::*pMethodArg)(A...)const) : pObject(pObjectArg), pMethod(pMethodArg) {}
    ConstMethodFunctor(const C& objectArg, R(C::*pMethodArg)(A...)const) : pObject(&objectArg), pMethod(pMethodArg) {}
    ConstMethodFunctor(const ConstMethodFunctor& arg) = default;
    ConstMethodFunctor& operator=(const ConstMethodFunctor& arg) = default;
    ~ConstMethodFunctor(void)noexcept override = default;
 
public: // static operations
    template<class ...Args>
    static R Invoke(void* pArg, Args&& ...args)
    {
        ConstMethodFunctor* pThis = static_cast<ConstMethodFunctor*>(pArg);
        return ((pThis->pObject)->*(pThis->pMethod))(std::forward<Args>(args)...);
    }
 
protected: // overidden operations
    bool Equals(const ConstMethodFunctor& other)override
    {
        return this->pObject == other.pObject && this->pMethod == other.pMethod;
    }
 
private: // fields
    const C*    pObject;
    MethodPtr   pMethod;
};
 
// inline methods of class MethodDelegateFunctor
 
 
}}}} // end of namespace Arp::System::Core::Impl