std::delegate< TReciever, TYPE, TSender > Template-Klassenreferenz

#include <event.hpp>

Klassendiagramm für std::delegate< TReciever, TYPE, TSender >:

Zusammengehörigkeiten von std::delegate< TReciever, TYPE, TSender >:

Öffentliche Typen
using	self_type = delegate_base< TYPE, TSender >
using	const_self_type = const delegate_base< TYPE, TSender >
using	sender_type = TSender
using	value_type = TYPE

Öffentliche Methoden
	delegate (TReciever *p_ptr2Object, callFunction p_ptr2Func)
bool	operator== (const delegate_base< TYPE, TSender > *pOther)
virtual void	call (const TSender *pSender, const TYPE pParam)
virtual bool	operator== (const_self_type *pOther)=0

Ausführliche Beschreibung

template<class TReciever, typename TYPE, class TSender = object>
class std::delegate< TReciever, TYPE, TSender >

Dokumentation der benutzerdefinierten Datentypen

const_self_type

template<typename TYPE , class TSender = eventArgs>

using std::delegate_base< TYPE, TSender >::const_self_type = const delegate_base<TYPE, TSender>

inherited

self_type

template<typename TYPE , class TSender = eventArgs>

using std::delegate_base< TYPE, TSender >::self_type = delegate_base<TYPE, TSender>

inherited

sender_type

template<typename TYPE , class TSender = eventArgs>

using std::delegate_base< TYPE, TSender >::sender_type = TSender

inherited

value_type

template<typename TYPE , class TSender = eventArgs>

using std::delegate_base< TYPE, TSender >::value_type = TYPE

inherited

Beschreibung der Konstruktoren und Destruktoren

delegate()

template<class TReciever , typename TYPE , class TSender = object>

std::delegate< TReciever, TYPE, TSender >::delegate ( TReciever *  p_ptr2Object, callFunction  p_ptr2Func  )

inline

                                                              {
            m_ptr2Func      = p_ptr2Func;
            m_ptr2Object    = p_ptr2Object;
    }

Dokumentation der Elementfunktionen

call()

template<class TReciever , typename TYPE , class TSender = object>

virtual void std::delegate< TReciever, TYPE, TSender >::call ( const TSender *  pSender, const TYPE  pParam  )

inlinevirtual

Implementiert std::delegate_base< TYPE, TSender >.

                                                               {
            assert(pSender != NULL);
            (m_ptr2Object->*m_ptr2Func)(pSender, pParam);
    }

operator==() [1/2]

template<typename TYPE , class TSender = eventArgs>

virtual bool std::delegate_base< TYPE, TSender >::operator== ( const_self_type *  pOther )

pure virtualinherited

operator==() [2/2]

template<class TReciever , typename TYPE , class TSender = object>

bool std::delegate< TReciever, TYPE, TSender >::operator== ( const delegate_base< TYPE, TSender > *  pOther )

inline

                                                                 {
            const delegate<TReciever, TYPE, TSender>* other;
            other = static_cast<const delegate<TReciever, TYPE, TSender>*>(pOther);
            assert(other != NULL);
            assert(m_ptr2Object != NULL);
            return other->m_ptr2Object == m_ptr2Object && other->m_ptr2Func == m_ptr2Func;
    }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/event.hpp