deferredcallers.hpp

Go to the documentation of this file.

#ifndef EASYDELEGATE_NO_DEFERRED_CALLING
#ifndef _INCLUDE_EASYDELEGATE_DEFERREDCALLERS_HPP_
#define _INCLUDE_EASYDELEGATE_DEFERREDCALLERS_HPP_

#include <assert.h> // assert(expr)
#include <tuple>    // std::tuple

namespace EasyDelegate
{
    class IDeferredCaller
    {
        // Public Methods
        public:
            EASYDELEGATE_INLINE virtual void genericDispatch(void) const = 0;

            EASYDELEGATE_INLINE virtual bool hasThisPointer(const void* thisPointer) const noexcept { return false; }
    };

    template <typename returnType>
    class ITypedDeferredCaller : public IDeferredCaller
    {
        // Public Methods
        public:
            EASYDELEGATE_INLINE virtual returnType dispatch(void) const = 0;
    };

    template <typename className, typename returnType, typename... parameters>
    class DeferredMemberCaller;

    template <typename returnType, typename... parameters>
    class DeferredStaticCaller : public ITypedDeferredCaller<returnType>
    {
        // Public Methods
        public:
            typedef returnType(*StaticDelegateMethodPointer)(parameters...);

            DeferredStaticCaller(const StaticDelegateMethodPointer methodPointer, parameters... params) :
            mParameters(params...), mMethodPointer(methodPointer) { }

            EASYDELEGATE_INLINE returnType dispatch(void) const
            {
                assert(mMethodPointer);

                if (!mMethodPointer)
                    throw InvalidMethodPointerException();

                return performCachedCall(typename gens<sizeof...(parameters)>::type());
            }

            EASYDELEGATE_INLINE void genericDispatch(void) const { dispatch(); }

            EASYDELEGATE_INLINE bool callsMethod(const StaticDelegateMethodPointer methodPointer) const noexcept { return mMethodPointer == methodPointer; }

            template <typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool callsMethod(const StaticMethodPointer<otherReturn, otherParams...> methodPointer) const noexcept { return false; }

            template <typename otherClass, typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool callsMethod(const MemberMethodPointer<otherClass, otherReturn, otherParams...> methodPointer) const noexcept { return false; }

            EASYDELEGATE_INLINE bool hasSameMethodAs(const DeferredStaticCaller<returnType, parameters...>* other) const noexcept { return mMethodPointer == other->mMethodPointer; }

            template <typename otherClass, typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameMethodAs(const DeferredMemberCaller<otherClass, otherReturn, otherParams...>* other) const noexcept { return false; }

            template <typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameMethodAs(const DeferredStaticCaller<otherReturn, otherParams...>* other) const noexcept { return false; }

            EASYDELEGATE_INLINE bool hasThisPointer(const void* thisPointer) const noexcept { return false; }

            template <typename otherClass, typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameThisPointerAs(const IDeferredCaller* other) const noexcept { return false; }

        // Private Methods
        private:
            template<int ...S>
            EASYDELEGATE_INLINE EASYDELEGATE_CONSTEXPR returnType performCachedCall(seq<S...>) const
            {
                return (mMethodPointer)(std::get<S>(mParameters) ...);
            }

            const StaticDelegateMethodPointer mMethodPointer;
            const NoReferenceTuple<parameters...> mParameters;
    };

    template <typename classType, typename returnType, typename... parameters>
    class DeferredMemberCaller : public ITypedDeferredCaller<returnType>
    {
        // Public Methods
        public:
            typedef MemberMethodPointer<classType, returnType, parameters...> MemberDelegateMethodPointer;

            DeferredMemberCaller(const MemberDelegateMethodPointer methodPointer, classType* thisPointer, parameters... params) :
            mThisPointer(thisPointer), mParameters(params...), mMethodPointer(methodPointer) { }

            EASYDELEGATE_INLINE returnType dispatch(void) const
            {
                assert(mThisPointer);
                assert(mMethodPointer);

                if (!mThisPointer)
                    throw InvalidThisPointerException();

                if (!mMethodPointer)
                    throw InvalidMethodPointerException();

                return performCachedCall(typename gens<sizeof...(parameters)>::type());
            }

            EASYDELEGATE_INLINE void genericDispatch(void) const { dispatch(); }

            EASYDELEGATE_INLINE bool callsMethod(const MemberDelegateMethodPointer methodPointer) const noexcept { return methodPointer == mMethodPointer; }

            template <typename otherClass, typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool callsMethod(const MemberMethodPointer<otherClass, otherReturn, otherParams...> methodPointer) const noexcept { return false; }

            template <typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool callsMethod(const StaticMethodPointer<otherReturn, otherParams...> methodPointer) const noexcept { return false; }

            EASYDELEGATE_INLINE bool hasSameMethodAs(const DeferredMemberCaller<classType, returnType, parameters...>* other) const noexcept { return mMethodPointer == other->mMethodPointer; }

            template <typename otherClass, typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameMethodAs(const DeferredMemberCaller<otherClass, otherReturn, otherParams...>* other) const noexcept { return false; }

            template <typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameMethodAs(const DeferredStaticCaller<otherReturn, otherParams...>* other) const noexcept { return false; }

            template <typename otherClass, typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameThisPointerAs(const DeferredMemberCaller<otherClass, otherReturn, otherParams...>* other) const noexcept { return reinterpret_cast<void*>(mThisPointer) == reinterpret_cast<void*>(other->mThisPointer); }

            template <typename otherReturn, typename... otherParams>
            EASYDELEGATE_INLINE bool hasSameThisPointerAs(const DeferredStaticCaller<otherReturn, otherParams...>* other) const noexcept { return false; }

            EASYDELEGATE_INLINE bool hasThisPointer(const void* thisPointer) const noexcept { return reinterpret_cast<const void*>(mThisPointer) == reinterpret_cast<const void*>(thisPointer); }

        // Public Members
        public:
            classType* mThisPointer;

        // Private Methods
        private:
            template<int ...S>
            EASYDELEGATE_INLINE EASYDELEGATE_CONSTEXPR returnType performCachedCall(seq<S...>) const
            {
                assert(mThisPointer);

                if (!mThisPointer)
                    throw InvalidThisPointerException();

                return (mThisPointer->*mMethodPointer)(std::get<S>(mParameters) ...);
            }

        // Private Members
        private:
            const MemberDelegateMethodPointer mMethodPointer;

            const NoReferenceTuple<parameters...> mParameters;
    };
} // End NameSpace EasyDelegate
#endif // _INCLUDE_EASYDELEGATE_DEFERREDCALLERS_HPP_
#endif // EASYDELEGATE_NO_DEFERRED_CALLING