// SharedMutexHolder.tli
//

#pragma once


#include "SharedMutexHolder.tlh"


template <typename T>
SharedMutexHolder <T>::SharedMutexHolder ()
{
	m_pObject = NULL;
}


template <typename T>
SharedMutexHolder <T>::~SharedMutexHolder ()
{
	UpdateLock Lock (this);
	delete m_pObject;
}

template <typename T>
SharedMutexHolder <T>::SharedMutexHolder (T * object)
{
	m_pObject = object;
}


template <typename T>
void SharedMutexHolder <T>::Attach (T * obj)
{
	UpdateLock Lock (this);

	delete m_pObject;
	m_pObject = obj;
}


template <typename T>
bool SharedMutexHolder <T>::Update (T && obj)
{
	UpdateLock Lock (this);

	if (m_pObject)
	{
		*m_pObject = std::move (obj);
		return true;
	}
	else
	{
		m_pObject = new T (std::move (obj));
		return false;
	}
}


template <typename T>
T * SharedMutexHolder <T>::Detach ()
{
	UpdateLock Lock (this);

	T * old = m_pObject;
	m_pObject = NULL;
	Release ();

	return old;
}


template <typename T>
void SharedMutexHolder <T>::Release ()
{
	UpdateLock Lock (this);

	delete m_pObject;
	m_pObject = NULL;
}


template <typename T>
SharedMutexHolder <T> & SharedMutexHolder <T>::operator = (T * object)
{
	Attach (object);
	return *this;
}


template <typename T>
bool SharedMutexHolder <T>::IsEmpty () const
{
	ReadLock Lock (this);

	return (m_pObject == NULL);
}


//-----------------------------------------------------------------------------
//	ReadLock
//-----------------------------------------------------------------------------

template <typename T>
SharedMutexHolder <T>::ReadLock::ReadLock (const SharedMutexHolder <T> * holder)
	: m_Lock { std::shared_lock < std::shared_mutex > (holder->m_Mutex) }
	, m_Holder (holder)
{
	assert (m_Holder);
}

template <typename T>
SharedMutexHolder <T>::ReadLock::ReadLock (ReadLock && from)
{
	m_Lock.swap (from.m_Lock);
	m_Holder = from.m_Holder;
}


template <typename T>
T * SharedMutexHolder <T>::ReadLock::As ()
{
	return m_Holder->m_pObject;
}


template <typename T>
const T * SharedMutexHolder <T>::ReadLock::As () const
{
	return m_Holder->m_pObject;
}

template <typename T>
template <typename C> C * SharedMutexHolder <T>::ReadLock::AS ()
{
	return m_Holder->m_pObject;
}

template <typename T>
template <typename C> const C * SharedMutexHolder <T>::ReadLock::AS () const
{
	return m_Holder->m_pObject;
}



//-----------------------------------------------------------------------------
//	UpdateLock
//-----------------------------------------------------------------------------

template <typename T>
SharedMutexHolder <T>::UpdateLock::UpdateLock (SharedMutexHolder <T> * holder)
	: m_Lock { std::lock_guard < std::shared_mutex > (holder->m_Mutex) }
	, m_Holder (holder)
{
	assert (m_Holder);
}

template <typename T>
SharedMutexHolder <T>::UpdateLock::UpdateLock (ReadLock && from)
{
	m_Lock.swap (from.m_Lock);
	m_Holder = from.m_Holder;
}


template <typename T>
T * SharedMutexHolder <T>::UpdateLock::As ()
{
	return m_Holder->m_pObject;
}


template <typename T>
const T * SharedMutexHolder <T>::UpdateLock::As () const
{
	return m_Holder->m_pObject;
}

template <typename T>
template <typename C> C * SharedMutexHolder <T>::UpdateLock::AS ()
{
	return m_Holder->m_pObject;
}

template <typename T>
template <typename C> const C * SharedMutexHolder <T>::UpdateLock::AS () const
{
	return m_Holder->m_pObject;
}