delegates.hpp

Go to the documentation of this file.

#ifndef _INCLUDE_EASYDELEGATE_DELEGATES_HPP_
#define _INCLUDE_EASYDELEGATE_DELEGATES_HPP_

#include <assert.h>         // assert(expr)

#include "types.hpp"
#include "exceptions.hpp"

namespace EasyDelegate
{
    template <typename returnType, typename... parameters>
    class ITypedDelegate;

    class IDelegate
    {
        // Public Members
        public:
            const bool mIsMemberDelegate;

        // Protected Methods
        protected:
            IDelegate(const bool& isMemberDelegate) noexcept : mIsMemberDelegate(isMemberDelegate) { }
    };

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

    template <typename returnType, typename... parameters>
    class StaticDelegate : public ITypedDelegate<returnType, parameters...>
    {
        public:
            typedef StaticMethodPointer<returnType, parameters...> MethodPointer;

            StaticDelegate(const MethodPointer methodPointer) : ITypedDelegate<returnType, parameters...>(false), mMethodPointer(methodPointer) { }

            StaticDelegate(const StaticDelegate<returnType, parameters...>* other) : ITypedDelegate<returnType, parameters...>(false),
            mMethodPointer(other->mMethodPointer) { }

            returnType invoke(parameters... params)
            {
                assert(mMethodPointer);

                if (!mMethodPointer)
                    throw InvalidMethodPointerException();

                return ((MethodPointer)mMethodPointer)(params...);
            }

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

            EASYDELEGATE_INLINE bool callsMethod(const MethodPointer 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; }

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

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

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

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

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

        private:
            const MethodPointer mMethodPointer;
    };

    template <typename classType, typename returnType, typename... parameters>
    class MemberDelegate : public ITypedDelegate<returnType, parameters...>
    {
        public:
            typedef MemberMethodPointer<classType, returnType, parameters...> MethodPointer;

            MemberDelegate(const MethodPointer methodPointer, classType* thisPointer) : mThisPointer(thisPointer),
            mMethodPointer(methodPointer), ITypedDelegate<returnType, parameters...>(true) { }

            MemberDelegate(const MemberDelegate<classType, returnType, parameters...>* other) : mThisPointer(other->mThisPointer),
            mMethodPointer(other->mMethodPointer), ITypedDelegate<returnType, parameters...>(true) { }

            returnType invoke(parameters... params)
            {
                assert(mThisPointer);
                assert(mMethodPointer);

                if (!mThisPointer)
                    throw InvalidThisPointerException();

                if (!mMethodPointer)
                    throw InvalidMethodPointerException();

                classType *thisPointer = (classType*)thisPointer;
                return (thisPointer->*mMethodPointer)(params...);
            }

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

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

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

            EASYDELEGATE_INLINE bool callsMethod(const typename ITypedDelegate<returnType, parameters...>::StaticMethodPointerType methodPointer) const noexcept { return false; }

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

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

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

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

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

        // Public Members
        public:
            classType* mThisPointer;

        private:
            const MethodPointer mMethodPointer;
    };

    template <typename returnType, typename... parameters>
    class ITypedDelegate : public IDelegate
    {
        // Public Members
        public:
            typedef returnType ReturnType;
            typedef StaticDelegate<returnType, parameters...> StaticDelegateType;
            template <typename classType>
            using MemberDelegateType = MemberDelegate<classType, returnType, parameters...>;

            typedef StaticMethodPointer<returnType, parameters...> StaticMethodPointerType;

            template <typename classType>
            using MemberDelegateFuncPtr = returnType(classType::*)(parameters...);

        // Public Methods
        public:
            ITypedDelegate(const bool& isMemberDelegate) noexcept : IDelegate(isMemberDelegate) { }

            virtual bool callsMethod(const StaticMethodPointerType methodPointer) const noexcept = 0;

            template <typename className>
            bool callsMethod(const MemberDelegateFuncPtr<className> methodPointer) const noexcept
            {
                // Don't try to check as a MemberDelegate if we're not actually one
                if (!mIsMemberDelegate)
                    return false;

                // This is a hack so that the proper callsMethod function is called to get the return value
                const MemberDelegate<className, returnType, parameters...>* memberDelegateObj = reinterpret_cast<const MemberDelegate<className, returnType, parameters...>*>(this);
                return memberDelegateObj->callsMethod(methodPointer);
            }

            virtual bool hasThisPointer(const void* thisPointer) const noexcept = 0;

            virtual returnType invoke(parameters... params) = 0;
    };
} // End NameSpace EasyDelegate
#endif // _INCLUDE_EASYDELEGATE_DELEGATES_HPP_