delegate.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#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
    delegate(void) = default;
    delegate(const delegate& arg) = default;
    delegate(delegate&& arg) = default;
    delegate& operator=(const delegate& arg) = default;
    delegate& operator=(delegate&& arg) = 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::forward<std::function<R(A...)>>(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::forward<std::function<R(A...)>>(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