delegateset.hpp

Go to the documentation of this file.

#ifndef _INCLUDE_EASYDELEGATE_DELEGATESET_HPP_
#define _INCLUDE_EASYDELEGATE_DELEGATESET_HPP_

#include <set>
#include <unordered_set>

#include "types.hpp"
#include "delegates.hpp"
#include "deferredcallers.hpp"

namespace EasyDelegate
{
    template <typename returnType, typename... parameters>
    class DelegateSet : public std::set<ITypedDelegate<returnType, parameters...> *>
    {
        public:
            typedef returnType (*delegateFuncPtr)(parameters...);

        public:
            typedef StaticDelegate<returnType, parameters...> StaticDelegateType;
            template <typename classType>
            using MemberDelegateType = MemberDelegate<classType, returnType, parameters...>;
            typedef returnType ReturnType;
            typedef ITypedDelegate<returnType, parameters...> StoredDelegateType;

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

            #ifndef EASYDELEGATE_NO_DEFERRED_CALLING

                template <typename classType>
                using DeferredMemberCallerType = DeferredMemberCaller<classType, returnType, parameters...>;

                typedef DeferredStaticCaller<returnType, parameters...> DeferredStaticCallerType;
            #endif

            typedef std::set<returnType> ReturnSetType;

            ~DelegateSet(void)
            {
                for (auto it = this->begin(); it != this->end(); it++)
                    delete *it;
            }

            EASYDELEGATE_INLINE void invoke(parameters... params) const
            {
                for (auto it = this->begin(); it != this->end(); it++)
                    (*it)->invoke(params...);
            }

            EASYDELEGATE_INLINE void invoke(std::set<returnType>& out, parameters... params) const
            {
                for (auto it = this->begin(); it != this->end(); it++)
                    out.insert(out.end(), (*it)->invoke(params...));
            }

            EASYDELEGATE_INLINE void push_back(StoredDelegateType* delegateInstance)
            {
                this->insert(this->end(), delegateInstance);
            }

            EASYDELEGATE_INLINE void operator +=(StoredDelegateType* delegateInstance)
            {
                this->push_back(delegateInstance);
            }

            template <typename className>
            EASYDELEGATE_INLINE void removeDelegateByMethod(const MemberDelegateFuncPtr<className> method, const bool& deleteInstances=true, std::unordered_set<StoredDelegateType *>* out=NULL)
            {
                for (auto it = this->begin(); it != this->end(); it++)
                {
                    StoredDelegateType* current = *it;

                    if (current->callsMethod(method))
                    {
                        if (deleteInstances)
                            delete current;
                        else if (out)
                            out->insert(out->end(), current);

                        this->erase(current);
                    }
                }
            }

            void removeDelegateByMethod(StaticDelegateFuncPtr methodPointer, const bool& deleteInstances=true, std::unordered_set<StoredDelegateType *>* out=NULL)
            {
                for (auto it = this->begin(); it != this->end(); it++)
                {
                    StoredDelegateType* current = *it;

                    if (current->callsMethod(methodPointer))
                    {
                        if (deleteInstances)
                            delete current;
                        else if (out)
                            out->insert(out->end(), current);

                        this->erase(current);
                    }
                }
            }

            void removeDelegateByThisPointer(const void* thisPtr, const bool& deleteInstances=true, std::unordered_set<StoredDelegateType *>* out=NULL)
            {
                for (auto it = this->begin(); it != this->end(); it++)
                {
                    StoredDelegateType* current = *it;

                    if (current->mIsMemberDelegate && current->hasThisPointer(thisPtr))
                    {
                        if (deleteInstances)
                            delete current;
                        else if (out)
                            out->insert(out->end(), current);

                        this->erase(current);
                    }
                }
            }

            StoredDelegateType* removeDelegate(StoredDelegateType* instance, const bool& deleteInstance=true)
            {
                for (auto it = this->begin(); it != this->end(); it++)
                {
                    StoredDelegateType* current = *it;

                    if (current == instance)
                    {
                        if (deleteInstance)
                            delete current;

                        this->erase(current);

                        if (deleteInstance)
                            return NULL;

                        return current;
                    }
                }

                return NULL;
            }
    };
}
#endif // _INCLUDE_EASYDELEGATE_DELEGATESET_HPP_