#pragma once


//
// UnlockedDelegate
//
class UnlockedDelegate : public Delegate
{
public:
	inline UnlockedDelegate ()
	{
	}

	inline UnlockedDelegate (const char * DelegateID) : Delegate (DelegateID)
	{
	}

	inline virtual ~UnlockedDelegate ()
	{
	}


	inline virtual void Invoke (const void * sender, DelegateArgs * arg)
	{
		int Size = GetSize ();
		if (Size == 0)
			return;

		DSingleLock Lock (& m_handlers.GetMutex (), true);

		if (Size <= DelegateMaxHandler)
		{
			DelegateHandler * arTemp [DelegateMaxHandler];
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp, DelegateMaxHandler);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				DelegateHandler * h = arTemp[Index];
				try
				{
					h->Invoke (sender, arg);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
		else
		{
			FixArray <DelegateHandler *> arTemp (m_handlers.GetSize ());
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				DelegateHandler * h = arTemp[Index];
				try
				{
					h->Invoke (sender, arg);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
	}


	template <class pfnForEach> void ForEach (pfnForEach pFunction)
	{
		int Size = GetSize ();
		if (Size == 0)
			return;

		DSingleLock Lock (& m_handlers.GetMutex (), true);
		m_ForEachBreak = false;

		if (Size <= DelegateMaxHandler)
		{
			DelegateHandler * arTemp [DelegateMaxHandler];
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp, DelegateMaxHandler);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (h);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
		else
		{
			FixArray <DelegateHandler *> arTemp (m_handlers.GetSize ());
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (h);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
	}

	template <class pfnForEach, class Parameter> void ForEach (pfnForEach pFunction, Parameter para)
	{
		int Size = GetSize ();
		if (Size == 0)
			return;

		DSingleLock Lock (& m_handlers.GetMutex (), true);
		m_ForEachBreak = false;

		if (Size <= DelegateMaxHandler)
		{
			DelegateHandler * arTemp [DelegateMaxHandler];
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp, DelegateMaxHandler);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (h, para);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
		else
		{
			FixArray <DelegateHandler *> arTemp (m_handlers.GetSize ());
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (h, para);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
	}


	template <class pfnForEach> void ForEach (pfnForEach pFunction, Delegate * SThis)
	{
		int Size = GetSize ();
		if (Size == 0)
			return;

		DSingleLock Lock (& m_handlers.GetMutex (), true);
		m_ForEachBreak = false;

		if (Size <= DelegateMaxHandler)
		{
			DelegateHandler * arTemp [DelegateMaxHandler];
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp, DelegateMaxHandler);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (SThis, h);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
		else
		{
			FixArray <DelegateHandler *> arTemp (m_handlers.GetSize ());
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (SThis, h);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
	}

	template <class pfnForEach, class Parameter> void ForEach (pfnForEach pFunction, Delegate * SThis, Parameter para)
	{
		int Size = GetSize ();
		if (Size == 0)
			return;

		DSingleLock Lock (& m_handlers.GetMutex (), true);
		m_ForEachBreak = false;

		if (Size <= DelegateMaxHandler)
		{
			DelegateHandler * arTemp [DelegateMaxHandler];
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp, DelegateMaxHandler);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (SThis, h, para);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
		else
		{
			FixArray <DelegateHandler *> arTemp (m_handlers.GetSize ());
//			int NbOfElem = m_handlers.CopyTo (arTemp, DelegateMaxHandler);
			const Array <DelegateHandler *> & ar = m_handlers;
			int NbOfElem = ar.CopyTo (arTemp);
			Lock.Unlock ();
			for (int Index=0; Index<NbOfElem; Index++)
			{
				if (m_ForEachBreak)
					break;

				DelegateHandler * h = arTemp[Index];
				try
				{
					pFunction (SThis, h, para);
				}
				catch (...)
				{
#ifdef _DEBUG
					Beep (1000, 1000);
					OnDelegateInvokeFailed (h);
#endif
				}
			}
		}
	}

};