head	1.1;
access;
symbols;
locks; strict;
comment	@# @;


1.1
date	2005.09.09.01.18.12;	author myevan;	state Exp;
branches;
next	;


desc
@@


1.1
log
@ó 
@
text
@#pragma once

#include <assert.h>

#define ETER_SMART_POINTER

namespace eter {

template<typename T>
class none_object : public T
{	
public:
	static T* instance()
	{
		static none_object<T> s_data;
		return &s_data;
	}

protected:
	bool __DeleteThis()
	{
		return true;
	}

public:
	none_object() {}
	virtual ~none_object() {}

	void * operator new(unsigned int mem_size)
    {	
		assert(!"NEW NONE_OBJECT");
		return instance();
    }
    void operator delete(void* pT)
    {				
		assert(!"DELETE NONE_OBJECT");
    }
};

template<typename T>
class smart_pointer_object
{
public:
	static T* None() 
	{
		return none_object<T>::instance();
	}

public:
	smart_pointer_object() : m_refCount(0) {}
	virtual ~smart_pointer_object() {}

	virtual bool IncRef() 
	{
		++m_refCount;
		return true;
	}
	virtual bool DecRef() 
	{
		assert(m_refCount>0);
		--m_refCount;
		if (m_refCount==0)
			__DeleteThis();

		return true;
	}
protected:
	virtual bool __DeleteThis()
	{
		delete this;
		return true;
	}
	
private:
	int m_refCount;
};

template<typename T>
class smart_pointer
{
public:
	smart_pointer() : m_ptr(T::None()) 
	{assert(NULL != m_ptr);m_ptr->IncRef();}

	smart_pointer(T* ptr) : m_ptr(ptr) 
	{assert(NULL != m_ptr);m_ptr->IncRef();}

	smart_pointer(const smart_pointer<T>& c_rsp) : m_ptr(c_rsp.m_ptr)
	{assert(NULL != m_ptr);m_ptr->IncRef();}

	~smart_pointer() 
	{
		m_ptr->DecRef();
	}

	inline void operator=(const smart_pointer<T>& c_rsp)
	{
		operator=(c_rsp.m_ptr);
	}
	inline void operator=(T* ptr)
	{
		assert(NULL != m_ptr);
		if (ptr)
		{
			ptr->IncRef();
			m_ptr->DecRef();
			m_ptr = ptr;		
		}		
		else
		{
			T* none = T::None();
			none->IncRef();
			m_ptr->DecRef();
			m_ptr = none;			
		}		
	}
	operator T* ()
	{
		assert(NULL != m_ptr);
		return m_ptr;
	}
	operator T* () const
	{
		assert(NULL != m_ptr);
		return m_ptr;
	}
	T& operator*()
	{
		assert(NULL != m_ptr);
		return *m_ptr;
	}
	T& operator*() const
	{
		assert(NULL != m_ptr);
		return *m_ptr;
	}
	T* operator->()
	{
		assert(NULL != m_ptr);
		return m_ptr;
	}
	T* operator->() const
	{
		assert(NULL != m_ptr);
		return m_ptr;
	}
private:
	T* m_ptr;
};


} // eter@
