//-----------------------------------------------------------------------------
//		XDWExclusiveHolder.tlh
//	允许互斥访问一个指针对象
//-----------------------------------------------------------------------------

#pragma once

#include <mutex>

#include "XDWHolder.tlh"
#include "XDWHolder.tli"


template <typename T> class XDWExclusiveHolder
{
	typedef T __BASE;

protected:
	T	* m_pObject;

public:
	XDWExclusiveHolder ();
	explicit XDWExclusiveHolder (T * object);

	virtual ~XDWExclusiveHolder ();

private:
//	禁止拷贝构造函数
	XDWExclusiveHolder (const XDWExclusiveHolder & h) = delete;
//	禁止复制
	XDWExclusiveHolder & operator = (const XDWExclusiveHolder & h) = delete;

public:
	void Attach (T * object);
	T * Detach ();

	XDWExclusiveHolder & operator = (T * object);

//	operator bool () const;

	bool IsEmpty () const;

	void Release ();

protected:
	mutable std::recursive_mutex m_Mutex;

public:
	class LockHolder
	{
	public:
		LockHolder (const XDWExclusiveHolder * holder);
		LockHolder (const LockHolder & h);
		~LockHolder ();

//		void Unlock ();
//		bool IsLocked () const { return m_Lock->IsLocked (); }

		T * As ();
		const T * As () const;

		template <typename C> C * AS ();
		template <typename C> const C * AS () const;

		T * operator -> ()
		{
			return As ();
		}
		const T * operator -> ()  const
		{
			return As ();
		}

	private:
		//	禁止复制操作
		LockHolder & operator = (const LockHolder & h) = delete;

	protected:
		XDWHolder <std::lock_guard < std::recursive_mutex > > m_Lock;
		const XDWExclusiveHolder * m_Holder;
	};

public:
	inline LockHolder Lock ()
	{
		return LockHolder (this);
	}

	inline LockHolder Lock () const
	{
		return LockHolder (this);
	}

	template <class Action> void LockExec (Action action)
	{
		LockHolder holder (this);
		action (holder.As ());
	}

	template <class Action> void LockExec (Action action) const
	{
		LockHolder holder (this);
		action (holder.As ());
	}
};