multicast_delegate.h

 
#ifndef _aspose_system_multicast_delegate_h_
#define _aspose_system_multicast_delegate_h_
 
#include "delegate.h"
#include "shared_ptr.h"
#include "exceptions.h"
#include "system/details/delegate_holding_variables.h"
#include <list>
#include <functional>
#include <algorithm>
#include <type_traits>
#include <utility>
 
#define ASPOSE_REMOVE_EMPTY_CALLBACKS
 
#ifdef ASPOSE_THREADSAFE_DELEGATES
#include <mutex>
#endif
 
namespace System
{
    class IAsyncResult;
 
    template<class Unused>
    class MulticastDelegate;
    
    using AsyncCallback = MulticastDelegate<void(SharedPtr<IAsyncResult>)>;
 
    struct MulticastDelegateTypeInfo : TypeInfoPtr
    {
        MulticastDelegateTypeInfo()
            : TypeInfoPtr(u"System::MulticastDelegate")
        {}
    };
 
    template <class ReturnType, class... ArgumentTypes>
    class ASPOSECPP_SHARED_CLASS MulticastDelegate<ReturnType(ArgumentTypes...)> : public Details::DelegateHoldingVariables
    {
    private:
        typedef MulticastDelegateTypeInfo ThisTypeInfo;
 
    public:
        using Callback = Delegate<ReturnType(ArgumentTypes...)>;
        using Function = ReturnType(ArgumentTypes...);
 
        MulticastDelegate()
        {
            m_callbacks = std::make_shared<const std::list<Callback>>();
        }
 
        ~MulticastDelegate()
        {}
 
        MulticastDelegate(std::nullptr_t) : MulticastDelegate()
        {}
 
        MulticastDelegate(const MulticastDelegate& o)
            : Details::DelegateHoldingVariables(o)
            , m_callbacks(o.m_callbacks)
        {}
 
        MulticastDelegate& operator=(const MulticastDelegate& o)
        {
            if ( this == &o )
                return *this;
 
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock(m_guard, o.m_guard);
            std::lock_guard<std::recursive_mutex> l1( m_guard, std::adopt_lock );
            std::lock_guard<std::recursive_mutex> l2(o.m_guard, std::adopt_lock);
#endif
            m_callbacks = o.m_callbacks;
            Details::DelegateHoldingVariables::operator = (o);
            return *this;
        }
 
        // movable
        MulticastDelegate(MulticastDelegate&& o) noexcept
            : Details::DelegateHoldingVariables(o)
            , m_callbacks(std::move(o.m_callbacks))
        {}
 
        MulticastDelegate& operator=(MulticastDelegate&& o) noexcept
        {
            m_callbacks = std::move(o.m_callbacks);
            Details::DelegateHoldingVariables::operator = (std::move(o));
            return *this;
        }
 
        MulticastDelegate(Callback&& initial) : MulticastDelegate()
        {
             mutable_list()->push_back(std::move(initial));
        }
 
        template <class T, typename = decltype(Callback(std::declval<T>()))>
        MulticastDelegate(T arg) : MulticastDelegate(Callback(arg))
        {
        }
 
        MulticastDelegate(std::function<ReturnType(ArgumentTypes...)> arg) : MulticastDelegate(Callback(arg))
        {
        }
 
        bool empty() const
        {
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock_guard<std::recursive_mutex> lock(m_guard);
#endif
 
#ifdef ASPOSE_REMOVE_EMPTY_CALLBACKS
            bool res = true;
            if (m_callbacks)
            {
                for (auto it = m_callbacks->begin(); it != m_callbacks->end(); ++it)
                    res &= it->Empty();
            }
            return res;
#else
            return m_callbacks->empty();
#endif
        }
 
        bool IsNull() const { return empty(); }
 
        const TypeInfo& GetType() const
        {
            return Type();
        }
 
        String ToString() const
        {
            return GetType().ToString();
        }
 
        int GetHashCode() const
        {
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock_guard<std::recursive_mutex> lock(m_guard);
#endif
            return System::GetHashCode(m_callbacks.get());
        }
 
        bool Equals(const MulticastDelegate& other)
        {
            return *this == other;
        }
 
        bool operator==(const std::nullptr_t&) const
        {
            return empty();
        }
 
        bool operator!=(const std::nullptr_t&) const
        {
            return !operator==(nullptr);
        }
 
        MulticastDelegate& connect(Callback callback)
        {
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock_guard<std::recursive_mutex> lock(m_guard);
#endif
 
            mutable_list()->push_back(std::move(callback));
 
            return *this;
        }
 
        template <class R, class... Args>
        MulticastDelegate& connect(std::function<R(Args...)> f)
        {
            return connect(Callback(f));
        }
 
        MulticastDelegate& connect(MulticastDelegate& other)
        {
            if (other.m_callbacks)
                for (auto &callback : *other.m_callbacks)
                    connect(callback);
            return *this;
        }
 
        template <class MemberType, class ClassType>
        MulticastDelegate& connect(MemberType ClassType::* member, ClassType * obj)
        {
            CODEPORTING_DEBUG_ASSERT( obj != nullptr );
            return connect(Callback(member, obj));
        }
 
        template <class MemberType, class ClassType>
        MulticastDelegate& connect(MemberType ClassType::* member, const SharedPtr<ClassType> & obj)
        {
            CODEPORTING_DEBUG_ASSERT(obj != nullptr);
            return connect(Callback(member, obj));
        }
 
        MulticastDelegate& operator +=(Callback callback)
        {
            return connect(std::move(callback));
        }
 
        MulticastDelegate& disconnect(Callback callback)
        {
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock_guard<std::recursive_mutex> lock(m_guard);
#endif
            auto callbacks = mutable_list();
            auto it = std::find_if(callbacks->rbegin(), callbacks->rend(), [&](const Callback& c){return callback == c;});
            if (it != callbacks->rend())
                callbacks->erase(std::next(it).base());
            return *this;
        }
 
        template <class MemberType, class ClassType>
        MulticastDelegate& disconnect(MemberType ClassType::* member, ClassType * obj)
        {
            CODEPORTING_DEBUG_ASSERT(obj != nullptr);
            return disconnect(Callback(member, obj));
        }
 
        template <class MemberType, class ClassType>
        MulticastDelegate& disconnect(MemberType ClassType::* member, const SharedPtr<ClassType> & obj)
        {
            CODEPORTING_DEBUG_ASSERT(obj != nullptr);
            return disconnect(Callback(member, obj));
        }
 
        MulticastDelegate& disconnect(MulticastDelegate& other)
        {
            if (other.m_callbacks)
            {
#ifdef ASPOSE_THREADSAFE_DELEGATES
                std::lock(m_guard, o.m_guard);
                std::lock_guard<std::recursive_mutex> l1(m_guard, std::adopt_lock);
                std::lock_guard<std::recursive_mutex> l2(o.m_guard, std::adopt_lock);
#endif
                for (auto &callback : *other.m_callbacks)
                    disconnect(callback);
            }
            return *this;
        }
 
        MulticastDelegate& operator -=(Callback callback)
        {
            return disconnect(std::move(callback));
        }
 
        bool operator == (const MulticastDelegate& other) const
        {
            CODEPORTING_DEBUG_ASSERT(m_callbacks != nullptr && other.m_callbacks != nullptr);
 
            // If both delegates point to same callback list - they are equal for sure
            if (m_callbacks == other.m_callbacks)
                return true;
 
            // Then compare all callbacks one for another
            return *m_callbacks == *other.m_callbacks;
        }
 
        bool operator != (const MulticastDelegate& other) const
        {
            return !operator == (other);
        }
 
        MulticastDelegate& disconnect_all_slots()
        {
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock_guard<std::recursive_mutex> lock(m_guard);
#endif
            mutable_list()->clear();
 
            return *this;
        }
 
        void remove_empty_callbacks() const
        {
            if (m_callbacks && !m_callbacks->empty())
            {
                // We don't need to get unique callbacks here, because even shared callbacks, if empty, are subject to cleanup.
                auto* mutable_callbacks = const_cast<std::list<Callback>*>(m_callbacks.get());
 
                for (auto it = mutable_callbacks->begin(); it != mutable_callbacks->end();)
                {
                    if (it->Empty())
                        it = mutable_callbacks->erase(it);
                    else
                        ++it;
                }
            }
        }
 
        ReturnType invoke(ArgumentTypes... args) const
        {
#ifdef ASPOSE_THREADSAFE_DELEGATES
            std::lock_guard<std::recursive_mutex> lock(m_guard);
#endif
 
#ifdef ASPOSE_REMOVE_EMPTY_CALLBACKS
            remove_empty_callbacks();
#endif
            if (m_callbacks && !m_callbacks->empty())
            {
                auto callbacks_copy = m_callbacks; // we must save the current callbacks list in case it will be changed during the call
                auto last = std::prev(callbacks_copy->end()); // always valid, m_callbacks is not empty
                for (auto it = callbacks_copy->begin(); it != last; ++it)
                    (*it)(args...); // ignore result!
 
                return (*last)(args...);
            }
 
            throw NullReferenceException(u"MulticastDelegate: Object reference not set to an instance of an object.");
        }
 
        ReturnType operator()(ArgumentTypes... args) const
        {
            return invoke(args...);
        }
 
        static const TypeInfo& Type()
        {
            return *static_holder<ThisTypeInfo>();
        }
 
 
        template <typename CallbackArgumentType>
        SharedPtr<IAsyncResult> BeginInvoke(ArgumentTypes... args, const AsyncCallback& member, const CallbackArgumentType& obj)
        {
            throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION);
        }
 
        ReturnType EndInvoke(const SharedPtr<IAsyncResult>&)
        {
            throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION);
        }
 
#if defined(ASPOSE_GET_SHARED_MEMBERS) || defined(__DBG_FOR_EACH_MEMBER)
        std::shared_ptr<Details::HeldVariables> GetHeldVariables() const
        {
            auto heldVariables = std::make_shared<Details::HeldVariables>();
 
            heldVariables->CopyFrom(m_heldVariables);
 
            if (m_callbacks && !m_callbacks->empty())
            {
                for (auto it = m_callbacks->cbegin(); it != m_callbacks->cend(); ++it)
                {
                    heldVariables->CopyFrom(it->GetHeldVariables());
                }
            }
 
            return heldVariables;
        }
#endif
 
    private:
        std::list<Callback>* mutable_list()
        {
            CODEPORTING_DEBUG_ASSERT(m_callbacks != nullptr);
 
            if (m_callbacks.use_count() > 1)
                m_callbacks = std::make_shared<std::list<Callback>>(*m_callbacks);
 
            return const_cast<std::list<Callback>*>(m_callbacks.get());
        }
 
        mutable std::shared_ptr<const std::list<Callback>> m_callbacks;
 
#ifdef ASPOSE_THREADSAFE_DELEGATES
        mutable std::recursive_mutex m_guard;
#endif
    };
 
    template <typename T>
    MulticastDelegate<T> operator+(MulticastDelegate<T> lhv, MulticastDelegate<T> rhv)
    {
        return lhv.connect(rhv);
    }
 
    template <typename T>
    MulticastDelegate<T> operator-(MulticastDelegate<T> lhv, MulticastDelegate<T> rhv)
    {
        return lhv.disconnect(rhv);
    }
 
    template <typename TTo> struct CastResult;
 
    template <typename T>
    struct ASPOSECPP_SHARED_CLASS CastResult<MulticastDelegate<T>>
    {
        typedef MulticastDelegate<T> type;
    };
 
    template <class T>
    struct IsBoxable<MulticastDelegate<T>> : std::true_type
    {
    };
 
} // namespace System
#endif // _aspose_system_multicast_delegate_h_