CppDelegate::Internal Namespace Reference

Only for library's internal use. More...

Classes
union	horrible_union
struct	DefaultVoidToVoid
struct	DefaultVoidToVoid< DefaultVoid >
struct	VoidToDefaultVoid
struct	VoidToDefaultVoid< void >
struct	SimplifyMemFunc
struct	SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE >
class	DelegateMemento
class	ClosurePtr
Typedefs
typedef void	DefaultVoid
Functions
template<class OutputClass, class InputClass>
OutputClass	implicit_cast (InputClass input)
template<class OutputClass, class InputClass>
OutputClass	horrible_cast (const InputClass input)
template<class Delegate, class FastDelegate>
bool	AddFastDelegate (Delegate &delegate, FastDelegate &addable)
template<class Delegate, typename Function>
bool	AddFunction (Delegate &delegate, Function function)
template<class Delegate, class Object, typename MemberFunction>
bool	AddMemberFunction (Delegate &delegate, Object *object, MemberFunction function)
template<class Delegate, class FastDelegate>
bool	RemoveAll (Delegate &delegate, FastDelegate &removable)
template<class Delegate, class FastDelegate>
bool	Remove (Delegate &delegate, FastDelegate &removable)
template<class Delegate>
void	Clear (Delegate &delegate)
Variables
const int	SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)())

---

Detailed Description

Only for library's internal use.

---

Typedef Documentation

typedef void CppDelegate::Internal::DefaultVoid

Definition at line 255 of file Delegate.h.

---

Function Documentation

template<class Delegate, class FastDelegate>

bool CppDelegate::Internal::AddFastDelegate	(	Delegate &	delegate,
		FastDelegate &	addable
	)			[inline]

Definition at line 1555 of file Delegate.h.

                {
                        
                        if (!delegate.me)
                        {
                                delegate.me = addable;
                        }
                        else
                        {
                                if (delegate.next == NULL)
                                {
                                        delegate.next = new Delegate(addable);
                                        if (delegate.next == NULL) return false;
                                }
                                else
                                {
                                        return delegate.next->Add(addable);
                                }
                        }
                        
                        return true;
                        
                } // AddFastDelegate

template<class Delegate, typename Function>

bool CppDelegate::Internal::AddFunction	(	Delegate &	delegate,
		Function	function
	)			[inline]

Definition at line 1579 of file Delegate.h.

                {
                        if (!delegate.me)
                        {
                                delegate.me.Bind(function);
                        }
                        else
                        {
                                if (delegate.next == NULL)
                                {
                                        delegate.next = new Delegate(function);
                                        if (delegate.next == NULL) return false;
                                }
                                else
                                {
                                        return delegate.next->Add(function);
                                }
                        }
                        
                        return true;
                        
                } // AddFunction

template<class Delegate, class Object, typename MemberFunction>

bool CppDelegate::Internal::AddMemberFunction	(	Delegate &	delegate,
		Object *	object,
		MemberFunction	function
	)			[inline]

Definition at line 1603 of file Delegate.h.

                {
                        if (!delegate.me)
                        {
                                delegate.me.Bind(object, function);
                        }
                        else
                        {
                                if (delegate.next == NULL)
                                {
                                        delegate.next = new Delegate(object, function);
                                        if (delegate.next == NULL) return false;
                                }
                                else
                                {
                                        return delegate.next->Add(object, function);
                                }
                        }
                        
                        return true;
                        
                } // AddMemberFunction

template<class Delegate>

void CppDelegate::Internal::Clear

(

Delegate &

delegate

)

[inline]

Definition at line 1705 of file Delegate.h.

                {
                        if (delegate.next != NULL)
                        {
                                delegate.next->Clear();
                                delete delegate.next;
                                delegate.next = NULL;
                        }
                        delegate.me.Clear();
                        
                } // Clear

template<class OutputClass, class InputClass>

OutputClass CppDelegate::Internal::horrible_cast

(

const InputClass

input

)

[inline]

Definition at line 208 of file Delegate.h.

                                                        {
        horrible_union<OutputClass, InputClass> u;
        // Cause a compile-time error if in, out and u are not the same size.
        // If the compile fails here, it means the compiler has peculiar
        // unions which would prevent the cast from working.
        typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u) 
                && sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1];
        u.in = input;
        return u.out;
}

template<class OutputClass, class InputClass>

OutputClass CppDelegate::Internal::implicit_cast

(

InputClass

input

)

[inline]

Definition at line 187 of file Delegate.h.

                                                  {
        return input;
}

template<class Delegate, class FastDelegate>

bool CppDelegate::Internal::Remove	(	Delegate &	delegate,
		FastDelegate &	removable
	)			[inline]

Definition at line 1675 of file Delegate.h.

                {
                        if (removable == delegate.me)
                        {
                                if (delegate.next == NULL)
                                {
                                        delegate.me.Clear();
                                }
                                else
                                {
                                        Delegate *cutOut = delegate.next;
                                        
                                        delegate.me = cutOut->me;
                                        delegate.next = cutOut->next;
                                        
                                        delete cutOut;
                                }
                        }
                        else
                        {
                                if (delegate.next == NULL)
                                        return false;
                                else
                                        return delegate.next->Remove(removable);
                        }
                        
                        return true;
                        
                } // Remove

template<class Delegate, class FastDelegate>

bool CppDelegate::Internal::RemoveAll	(	Delegate &	delegate,
		FastDelegate &	removable
	)			[inline]

Definition at line 1626 of file Delegate.h.

                {
                        if (removable == delegate.me)
                        {
                                if (delegate.next == NULL)
                                {
                                        delegate.me.Clear();
                                }
                                else
                                {
                                        Delegate *cutOut, *cutOutNext = delegate.next;
                                        
                                        while (cutOutNext->me == removable)
                                        {
                                                cutOut = cutOutNext;
                                                cutOutNext = cutOut->next;
                                                
                                                delete cutOut;
                                                
                                                if (cutOutNext == NULL)
                                                {
                                                        delegate.next = NULL;
                                                        delegate.me.Clear();
                                                        return true;
                                                }
                                        }
                                        
                                        delegate.me = cutOutNext->me;
                                        delegate.next = cutOutNext->next;
                                        
                                        delete cutOutNext;
                                        
                                        if (delegate.next != NULL)
                                                delegate.next->RemoveAll(removable);
                                        
                                }
                        }
                        else
                        {
                                if (delegate.next == NULL)
                                        return false;
                                else
                                        return delegate.next->RemoveAll(removable);
                        }
                        
                        return true;
                        
                } // RemoveAll

---

Variable Documentation

const int CppDelegate::Internal::SINGLE_MEMFUNCPTR_SIZE = sizeof(void (GenericClass::*)())

Definition at line 309 of file Delegate.h.

---

MTÜ TTÜ Robotiklubi