#pragma once

#include <vector>
#include <list>

#include "XDWExclusiveHolder.tlh"
#include "XDWExclusiveHolder.tli"

#include "VectorOfPtr.tlh"
#include "ListOfPtr.tlh"

#include "Iterator.tlh"


//-----------------------------------------------------------------------------
//		ExclusiveListOfPtr
//-----------------------------------------------------------------------------

template <class T>
class ExclusiveListOfPtr : public XDWExclusiveHolder <ListOfPtr <T> >
{
	typedef XDWExclusiveHolder <ListOfPtr <T> > inherited;

public:
	using container = ListOfPtr <T>;
	using reference = typename ListOfPtr <T>::reference;
	using const_reference = typename ListOfPtr <T>::const_reference;
	using const_iterator = typename ListOfPtr <T>::const_iterator;

public:
	ExclusiveListOfPtr ()
	{
		Attach (new ListOfPtr <T> ());
	}

public:
	bool IsEmpty () const
	{
		LockHolder Lock (this);

		if (m_pObject == NULL)  return true;

		return m_pObject->empty ();
	}

	template <class Action> void LockForEach (Action action)
	{
		LockHolder holder (this);

		for (auto Iter = Iterator::From (holder.As ()); Iter; Iter ++)
		{
			action (Iter ());
		}
	}

	template <class Action> int  LockForEachIf (Action action)
	{
		LockHolder holder (this);

		for (auto Iter = Iterator::From (holder.As ()); Iter; Iter ++)
		{
			if (! action (Iter ()))
				return Iter.Index ();
		}

		return -1;
	}
};





//-----------------------------------------------------------------------------
//		ExclusiveVectorOfPtr
//-----------------------------------------------------------------------------

template <class T>
class ExclusiveVectorOfPtr : public XDWExclusiveHolder <VectorOfPtr <T> >
{
	typedef XDWExclusiveHolder <VectorOfPtr <T> > inherited;

public:
	using container = ListOfPtr <T>;
	using reference = typename VectorOfPtr <T>::reference;
	using const_reference = typename VectorOfPtr <T>::const_reference;
	using const_iterator = typename VectorOfPtr <T>::const_iterator;

public:
	ExclusiveVectorOfPtr ()
	{
		Attach (new VectorOfPtr <T> ());
	}

public:
	bool IsEmpty () const
	{
		LockHolder Lock (this);

		if (m_pObject == NULL)  return true;

		return m_pObject->empty ();
	}

	template <class Action> void LockForEach (Action action)
	{
		LockHolder holder (this);

		for (auto Iter = Iterator::From (holder.As ()); Iter; Iter ++)
		{
			action (Iter ());
		}
	}

	template <class Action> int  LockForEachIf (Action action)
	{
		LockHolder holder (this);

		for (auto Iter = Iterator::From (holder.As ()); Iter; Iter ++)
		{
			if (! action (Iter ()))
				return Iter.Index ();
		}

		return -1;
	}
};