delegate.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
 
#ifndef ARP_USE_ARP_SYSTEM_CORE
 
#include "Arp/Base/Core/delegate.hxx"
 
#else
 
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Impl/StaticFunctor.hxx"
#include "Arp/System/Core/Impl/MethodFunctor.hxx"
#include "Arp/System/Core/Impl/ConstMethodFunctor.hxx"
#include "Arp/System/Core/Impl/LambdaFunctor.hxx"
#include <memory>
 
namespace Arp
{
 
using namespace Arp::System::Core;
 
template <typename T> class delegate;
 
 
 
// class delegate is implemented completely implicite inline to avoid
// code bloat in used Core classe and therefore reduce compile time
 
template<class R, class ...A>
class delegate<R(A...)>
{
private: // typedefs/usings
    using InvokerPtr = R(*)(void*, A && ...);
    using FunctorPtr = std::shared_ptr<Impl::IDelegateFunctor>;
 
public: // construction/destruction/assignment
    template<class Lambda>
    delegate(Lambda f) : delegate(new Impl::LambdaFunctor<R(A...)>(std::function<R(A...)>(f)), &Impl::LambdaFunctor<R(A...)>::Invoke) {}
    delegate(void) = default;
    delegate(const delegate& arg) = default;
    delegate(delegate&& arg)noexcept = default;
    delegate& operator=(const delegate& arg) = default;
    delegate& operator=(delegate&& arg)noexcept = default;
 
public: // static factory operations
    static delegate create(R(*const pFunction)(A...))
    {
        return{ new Impl::StaticFunctor<R(A...)>(pFunction), &Impl::StaticFunctor<R(A...)>::Invoke };
    }
 
    template <class C>
    static delegate create(C* pObject, R(C::*pMethod)(A...))noexcept
    {
        return{ new Impl::MethodFunctor<R(C::*)(A...)>(pObject, pMethod), &Impl::MethodFunctor<R(C::*)(A...)>::Invoke };
    }
 
    template <class C>
    static delegate create(C& object, R(C::*pMethod)(A...))noexcept
    {
        return{ new Impl::MethodFunctor<R(C::*)(A...)>(object, pMethod), &Impl::MethodFunctor<R(C::*)(A...)>::Invoke };
    }
 
    template <class C>
    static delegate create(const C* pObject, R(C::*pMethod)(A...)const)noexcept
    {
        return{ new Impl::ConstMethodFunctor<R(C::*)(A...)const>(pObject, pMethod), &Impl::ConstMethodFunctor<R(C::*)(A...)const>::Invoke };
    }
 
    template <class C>
    static delegate create(const C& object, R(C::*pMethod)(A...)const)noexcept
    {
        return{ new Impl::ConstMethodFunctor<R(C::*)(A...)const>(object, pMethod), &Impl::ConstMethodFunctor<R(C::*)(A...)const>::Invoke };
    }
 
    static delegate create(std::function<R(A...)>&& f)
    {
        return{ new Impl::LambdaFunctor<R(A...)>(std::move(f)), &Impl::LambdaFunctor<R(A...)>::Invoke };
    }
 
    static delegate create(const std::function<R(A...)>& f)
    {
        return{ new Impl::LambdaFunctor<R(A...)>(f), &Impl::LambdaFunctor<R(A...)>::Invoke };
    }
 
public: // operators
    bool operator==(const delegate& rhs)const noexcept
    {
        return *this->functorPtr == *rhs.functorPtr;
    }
 
    bool operator!=(const delegate& rhs)const noexcept
    {
        return !(this->operator==(rhs));
    }
 
public: // nullptr and bool support
    delegate(std::nullptr_t) noexcept : delegate(nullptr, nullptr) { }
 
    bool operator==(std::nullptr_t const)const noexcept
    {
        return this->functorPtr == nullptr;
    }
 
    bool operator!=(std::nullptr_t const)const noexcept
    {
        return this->functorPtr != nullptr;
    }
 
    explicit operator bool()const noexcept
    {
        return (bool)this->functorPtr;
    }
 
public: // property getter
    bool is_lambda(void)const
    {
        return (bool)(*this) && dynamic_cast<Impl::LambdaFunctor<R(A...)>*>(this->functorPtr.get()) != nullptr;
    }
 
public: // functor operator()
    R operator()(A... args)const
    {
        return this->pInvoker(this->functorPtr.get(), std::forward<A>(args)...);
    }
 
public: // management operations
    void reset()
    {
        this->pInvoker = nullptr;
        this->functorPtr = nullptr;
    }
 
private: // construction
    delegate(Impl::IDelegateFunctor* pFunctor, InvokerPtr pInvokerArg)noexcept
        : pInvoker(pInvokerArg)
        , functorPtr(pFunctor)
    {
    }
 
private: // fields
    InvokerPtr  pInvoker;
    FunctorPtr  functorPtr;
};
 
// make_delegate factory function
template<class R, class ...A>
inline delegate<R(A...)> make_delegate(R(*const function_ptr)(A...))noexcept
{
    return delegate<R(A...)>::create(function_ptr);
}
 
template<class C, class R, class ...A>
inline delegate<R(A...)> make_delegate(C* const pObject, R(C::*const pMethod)(A...))noexcept
{
    return delegate<R(A...)>::create(pObject, pMethod);
}
 
template<class C, class R, class ...A>
inline delegate<R(A...)> make_delegate(C const* const pObject, R(C::*const pMethod)(A...)const)noexcept
{
    return delegate<R(A...)>::create(pObject, pMethod);
}
 
template<class C, class R, class ...A>
inline delegate<R(A...)> make_delegate(C& object, R(C::*const pMethod)(A...))noexcept
{
    return delegate<R(A...)>::create(object, pMethod);
}
 
template<class C, class R, class ...A>
inline delegate<R(A...)> make_delegate(const C& object, R(C::*const pMethod)(A...)const)noexcept
{
    return delegate<R(A...)>::create(object, pMethod);
}
 
template<class R, class ...A>
inline delegate<R(A...)> make_delegate(std::function<R(A...)>&& f)noexcept
{
    return delegate<R(A...)>::create(std::move(f));
}
 
template<class R, class ...A>
inline delegate<R(A...)> make_delegate(const std::function<R(A...)>& f)noexcept
{
    return delegate<R(A...)>::create(f);
}
 
 
} // end of namespace Arp
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE