DelegateContainer.h

Go to the documentation of this file.

#pragma once

#include "swCommonLib/Common/TypesDefinitions.h"
#include "swCommonLib/External/FastDelegate/FastDelegate.h"

#include "RegisteredEvent.h"

#include <vector>




namespace sw {
namespace gui
{



class DelegatesContainerBase;
struct IEventArgs;
class UIElement;
DEFINE_OPTR_TYPE( DelegatesContainerBase );

template< typename EventArgType >
using EventDelegate = fastdelegate::FastDelegate2< UIElement*, EventArgType* >;


class DelegatesContainerBase
{
private:

    DelegatesContainerBaseOPtr  m_next;         
    EventType                   m_eventType;    

protected:
public:
    explicit        DelegatesContainerBase      ( EventType eventID );
    virtual         ~DelegatesContainerBase     () = default;


    inline EventType            GetEventType        ()      { return m_eventType; }


    DelegatesContainerBase*     GetNextContainer    ()      { return m_next.get(); }
    
    void                        AddContainer        ( DelegatesContainerBaseOPtr&& container );
    
    void                        RemoveNext          ();

    DelegatesContainerBaseOPtr  StealRestOfList     ();

    virtual void                CallDelegates       ( UIElement* sender, IEventArgs* arguments ) = 0;
};



template< typename EventArgType >
class DelegatesContainer : public DelegatesContainerBase
{
public:

    typedef EventDelegate< EventArgType > DelegateType;

private:

    std::vector< DelegateType >     m_delegates;        

protected:
public:
    explicit        DelegatesContainer      ( EventType type );
    virtual         ~DelegatesContainer     () = default;


    inline void         operator+=		( DelegateType delegate );
    void                AddDelegate     ( DelegateType delegate );
    bool                RemoveDelegate  ( DelegateType delegate );

    bool                Exists          ( DelegateType delegate );
    bool                IsEmpty         () const;

    
    virtual void        CallDelegates   ( UIElement* sender, IEventArgs* arguments ) override;
};


//====================================================================================//
//          Implementation  
//====================================================================================//

// ================================ //
//
inline DelegatesContainerBase::DelegatesContainerBase   ( EventType eventID )
    :   m_eventType( eventID )
    ,   m_next( nullptr )
{}

// ================================ //
//
inline void             DelegatesContainerBase::AddContainer    ( DelegatesContainerBaseOPtr&& container )
{
    if( !m_next )
        m_next = std::move( container );
    else
        m_next->AddContainer( std::move( container ) );
}

// ================================ //
//
inline void             DelegatesContainerBase::RemoveNext      ()
{
    if( !m_next )
        return;

    // This will release our m_next and steal followers m_next;
    m_next = std::move( m_next->m_next );
}

// ================================ //
//
inline DelegatesContainerBaseOPtr   DelegatesContainerBase::StealRestOfList()
{
    return std::move( m_next );
}



//====================================================================================//
//              DelegatesContainer
//====================================================================================//


// ================================ //
//
template< typename EventArgType >
inline                  DelegatesContainer< EventArgType >::DelegatesContainer  ( EventType type )
    :   DelegatesContainerBase( type )
{}

// ================================ //
//
template< typename EventArgType >
inline void             DelegatesContainer< EventArgType >::operator+=		( typename DelegatesContainer< EventArgType >::DelegateType delegate )
{
    AddDelegate( delegate );
}

// ================================ //
//
template< typename EventArgType >
inline void             DelegatesContainer< EventArgType >::AddDelegate     ( typename DelegatesContainer< EventArgType >::DelegateType delegate )
{
    if( !Exists( delegate ) )
        m_delegates.push_back( delegate );
}

// ================================ //
//
template< typename EventArgType >
inline bool             DelegatesContainer< EventArgType >::RemoveDelegate  ( typename DelegatesContainer< EventArgType >::DelegateType delegate )
{
    bool removed = false;
    for( auto iter = m_delegates.begin(); iter != m_delegates.end(); )
    {
        if( *iter == delegate )
        {
            iter = m_delegates.erase( iter );
            removed = true;
        }
        else
            iter++;
    }

    return removed;
}

// ================================ //
//
template< typename EventArgType >
inline bool             DelegatesContainer< EventArgType >::Exists          ( typename DelegatesContainer< EventArgType >::DelegateType delegate )
{
    for( auto& exisitingDelegate : m_delegates )
    {
        if( exisitingDelegate == delegate )
            return true;
    }
    return false;
}

// ================================ //
//
template< typename EventArgType >
inline bool             DelegatesContainer< EventArgType >::IsEmpty() const
{
    return m_delegates.empty();
}

// ================================ //
//
template< typename EventArgType >
inline void             DelegatesContainer< EventArgType >::CallDelegates   ( UIElement* sender, IEventArgs* arguments )
{
    // @todo What should be done if event will be marked as handled ??
    EventArgType* typedArgs = static_cast< EventArgType* >( arguments );
    for( auto& delegateFun : m_delegates )
        delegateFun( sender, typedArgs );
}

}   // gui
}   // sw