// XDWHolder.tli
//

#pragma once


#ifndef ASSERT
#include <assert.h>
#define ASSERT assert
#endif


#include "XDWHolder.tlh"


#define Datanullptr nullptr


template <typename T>
XDWHolder <T>::XDWHolder ()
{
	Init ();
}


template <typename T>
XDWHolder <T>::~XDWHolder ()
{
	if (GetData () != Datanullptr)
	{
		if (InterlockedDecrement (&GetData ()->nRefs) <= 0)
		{
			delete m_pMetaData;
			delete m_pObject;
		}
	}
}


template <typename T>
void XDWHolder <T>::Init (void)
{
	m_pObject = nullptr;
	m_pMetaData = (MetaData *) Datanullptr;
}


template <typename T>
XDWHolder <T>::XDWHolder (const XDWHolder <T> & h)
{
	Init ();
	ShadowCopyFrom (h);
}


template <typename T>
XDWHolder <T>::XDWHolder (XDWHolder <T> && h)
{
	m_pObject = h.m_pObject;
	m_pMetaData = h.m_pMetaData;

	h.Init ();
}


template <typename T>
XDWHolder <T>::XDWHolder (T * object)
{
	Init ();
	Attach (object);
}


template <typename T>
void XDWHolder <T>::Attach (T * object)
{
	Release ();

	if (object == nullptr)
		return;

	m_pObject = object;
	m_pMetaData = new MetaData;
	m_pMetaData->nRefs = 1;
}

template <typename T>
T * XDWHolder <T>::Detach ()
{
	T * over = m_pObject;
	m_pObject = nullptr;
	Release ();

	return over;
}


template <typename T>
void XDWHolder <T>::Release ()
{
	if (GetData () == Datanullptr)  return;

	ASSERT (GetData ()->nRefs != 0);
	if (InterlockedDecrement (&GetData ()->nRefs) <= 0)
	{
		if (m_pObject)
			delete (m_pObject);
		delete m_pMetaData;
		m_pMetaData = nullptr;
	}

	Init ();
}


template <typename T>
void XDWHolder <T>::CopyFrom (const XDWHolder <T> & h)
{
	Release ();

	if (! h.m_pObject)  return;

	T * object = h.NewObject (h.m_pObject);

	ASSERT (object);

	Attach (object);
}

template <typename T>
void XDWHolder <T>::ShadowCopyFrom (const XDWHolder <T> & h)
{
	if (m_pObject == h.m_pObject)
		return;

	if (h.GetData () == Datanullptr)
	{
		Release ();
		return;
	}

	if (GetData () != Datanullptr)
	if (GetData ()->nRefs < 0)
	{
		CopyFrom (h);
		return;
	}

	if (h.GetData ()->nRefs < 0)
	{
		CopyFrom (h);
		return;
	}
//	else
	{
		// can just copy references around
		Release ();
		m_pObject	= h.m_pObject;
		m_pMetaData	= h.m_pMetaData;
		InterlockedIncrement (&GetData ()->nRefs);
	}
}


template <typename T>
T * XDWHolder <T>::NewObject (const T * fromObject) const
{
//	T * object = new T (* fromObject);
//	return object
	return nullptr;
}


template <typename T>
XDWHolder <T> & XDWHolder <T>::operator = (const XDWHolder <T> & h)
{
	ShadowCopyFrom (h);
	return *this;
}


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


template <typename T>
XDWHolder <T>::operator bool () const
{
	return m_pObject;
}


template <typename T>
XDWHolder <T>::operator T * ()
{
	return m_pObject;
}

template <typename T>
XDWHolder <T>::operator const T * () const
{
	return m_pObject;
}


template <typename T>
bool XDWHolder <T>::IsEmpty () const
{
	return (m_pObject == nullptr);
}