delegate.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/Detail/IDelegateFunctor.hpp"
#include <memory>
namespace Arp { namespace Base { namespace Core
{
 
template<typename T> class delegate;
 
template<class R, class ...A>
class delegate<R(A...)>
{
private: // usings
    using IDelegateFunctor = Arp::Base::Core::IDelegateFunctor;
    using FunctorPtr = std::shared_ptr<IDelegateFunctor>;
    using InvokerPtr = R(*)(IDelegateFunctor*, A...);
 
public: // construction
    delegate(std::nullptr_t)noexcept;
    template<class Lambda> delegate(Lambda f);
 
public: // canonical construction/destruction/assignment
    delegate(void);
 
public: // static factory operations
    static delegate create(R(* const pFunction)(A...));
    static delegate create(std::function<R(A...)>&& f);
    static delegate create(const std::function<R(A...)>& f);
 
    template <class C> static delegate create(C* pObject, R(C::* pMethod)(A...))noexcept;
    template <class C> static delegate create(C& object, R(C::* pMethod)(A...))noexcept;
    template <class C> static delegate create(const C* pObject, R(C::* pMethod)(A...)const)noexcept;
    template <class C> static delegate create(const C& object, R(C::* pMethod)(A...)const)noexcept;
 
public: // operators
    bool operator==(const delegate& rhs)const noexcept;
    bool operator!=(const delegate& rhs)const noexcept;
    bool operator==(std::nullptr_t const)const noexcept;
    bool operator!=(std::nullptr_t const)const noexcept;
    operator bool()const noexcept;
 
public: // getter/setter
    bool is_lambda(void)const;
 
public: // functor operator()
    R operator()(A... args)const;
 
public: // management operations
    void reset(void);
 
private: // construction
    delegate(FunctorPtr&& pFunctor, InvokerPtr pInvoker)noexcept;
 
private: // fields
    InvokerPtr  pInvoker = nullptr;
    FunctorPtr  functorPtr = nullptr;
};
 
// prototypes of factory function make_delegate
 
template<class R, class ...A>
delegate<R(A...)> make_delegate(R(* const function_ptr)(A...))noexcept;
 
template<class C, class R, class ...A>
delegate<R(A...)> make_delegate(C* const pObject, R(C::* const pMethod)(A...))noexcept;
 
template<class C, class R, class ...A>
delegate<R(A...)> make_delegate(C const* const pObject, R(C::* const pMethod)(A...)const)noexcept;
 
template<class C, class R, class ...A>
delegate<R(A...)> make_delegate(C& object, R(C::* const pMethod)(A...))noexcept;
 
template<class C, class R, class ...A>
delegate<R(A...)> make_delegate(const C& object, R(C::* const pMethod)(A...)const)noexcept;
 
template<class R, class ...A>
delegate<R(A...)> make_delegate(std::function<R(A...)>&& f)noexcept;
 
template<class R, class ...A>
delegate<R(A...)> make_delegate(const std::function<R(A...)>& f)noexcept;
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::delegate;
using Arp::Base::Core::make_delegate;
}
#include "Arp/Base/Core/Detail/delegate.ipp"