_manage.h

http代理程序

/************************************
  REVISION LOG ENTRY
  Revision By: Alex Turc ( [e-mail] )
  Revised on 6/9/00 12:16:06 AM
  Comments: Automatic resource management support
 ************************************/

#ifndef ___manage_h__
#define ___manage_h__

#include "_obj_managers.h"

namespace extension
{

/*
Manage objects using reference-count tehnque.
T - managed type
M - manager class for managed classs
*/
template< class T, class M >
class reference_counted_object
{
public:

	// Managed type typedef
	typedef T managed_type;


	// Function name	: reference_counted_object< T, M >
	// Description	    : Constructs an not assigned object
	// Return type		: 
	reference_counted_object< T, M >()
	{
		init_object();
		m_pnRefCount = new long(1);
	}

	// Function name	: reference_counted_object< T, M >
	// Description	    : Constructs an automatic object and assigns the argument as managed object
	// Return type		: 
	// Argument         : T t
	reference_counted_object< T, M >( T& t )
	{		
		m_Object = t;
		m_pnRefCount = new long(1);
	}
	

	// Function name	: operator
	// Description	    : Assigns a object to this manager
	// Return type		: void 
	void operator()( T& t )
	{

		if( m_Object == t )
			return;

		(*m_pnRefCount)--;
		if( *m_pnRefCount <= 0 )
			destroy_object();

		m_Object = t;
		m_pnRefCount = new long(1);		
	}


	// Function name	: M
	// Description	    : Copy constructor
	// Return type		: reference_counted_object< T, M >&
	// Argument         : reference_counted_object< T, M >& a
	reference_counted_object< T, M >( reference_counted_object< T, M >& a )
	{
		m_Object = a.m_Object;
		m_pnRefCount = a.m_pnRefCount;		
		(*m_pnRefCount)++;
	}


	// Function name	: ~reference_counted_object< T, M >
	// Description	    : 
	// Return type		: virtual ~reference_counted_object< 
	virtual ~reference_counted_object< T, M >()
	{
		(*m_pnRefCount)--;
		if( *m_pnRefCount == 0 )
			destroy_object();
	}

	

	// Function name	: operator = 
	// Description	    : 
	// Return type		: reference_counted_object< T, M >&
	// Argument         : reference_counted_object< T, M >& a
	reference_counted_object< T, M >& operator = ( reference_counted_object< T, M >& a )
	{
		if( this == &a || m_pnRefCount == a.m_pnRefCount )
			return *this;

		(*m_pnRefCount)--;
		if( *m_pnRefCount <= 0 )
			destroy_object();

		m_pnRefCount = a.m_pnRefCount;
		m_Object = a.m_Object;		
		(*m_pnRefCount)++;

		return *this;
	}


	// Function name	: operator = 
	// Description	    : 
	// Return type		: reference_counted_object< T, M >&
	// Argument         : T& t
	reference_counted_object< T, M >& operator = ( T& t )
	{
		operator()( t );
		return *this;
	}

	

	// Function name	: operator T
	// Description	    : Cast operator
	// Return type		: 
	operator T()
	{
		return m_Object;
	}
	

	// Function name	: operator == 
	// Description	    : Equality operator
	// Return type		: bool
	// Argument         : const reference_counted_object< T, M >& a
	// Argument         : 
	bool operator == ( const reference_counted_object< T, M >& a )
	{
		return m_Object == a.m_Object;
	}

	// Less than operator

	// Function name	: operator < 
	// Description	    : 
	// Return type		: bool
	// Argument         : const reference_counted_object< T, M >& a
	// Argument         : 
	bool operator < ( const reference_counted_object< T, M >& a )
	{
		return m_Object < a.m_Object;
	}


protected:

	// Object
	T m_Object;

	// Reference count
	long* m_pnRefCount;

	// Manager
	M m_Manager;

private:


	// Function name	: destroy_object
	// Description	    : Destroys the managed object
	// Return type		: void 
	void destroy_object()
	{
		// Destroy the attached object
		m_Manager.delete_object( m_Object );

		delete m_pnRefCount;
		m_pnRefCount = NULL;
	}


	// Function name	: init_object
	// Description	    : Object initialization
	// Return type		: void 
	void init_object()
	{
		// Init the attached object
		m_Manager.init_object( m_Object );

		delete m_pnRefCount;
		m_pnRefCount = NULL;
	}
};

/*
Automatic object
T - type of the managed object
M - object manager class
*/
template< class T, class M >
class automatic_object
{
public:

	// Managed type typedef
	typedef T managed_type;

	// Function name	: automatic_object< T, M >
	// Description	    : Constructs an not assigned object
	// Return type		: 
	automatic_object< T, M >()
	{
		init_object();
		bool m_bOwner = true;
	}

	// Function name	: automatic_object< T, M >
	// Description	    : Constructs an automatic object and assigns the argument as managed object
	// Return type		: 
	// Argument         : T t
	automatic_object< T, M >( T& t )
	{		
		m_Object = t;
		m_bOwner = true;
	}
	

	// Function name	: operator()
	// Description	    : Assigns a object to this manager
	// Return type		: void 
	void operator()( T& t )
	{
		if( m_Object == t )
			return;

		if( m_bOwner )
			destroy_object();

		m_Object = t;
		m_bOwner = true;
	}


	// Function name	: automatic_object< T, M >&
	// Description	    : Copy constructor
	// Return type		: 
	// Argument         : automatic_object< T, M >& a
	automatic_object< T, M >( automatic_object< T, M >& a )
	{
		m_Object = a.m_Object;
		m_bOwner = a.m_bOwner;
		a.m_bOwner = false;
	}


	// Function name	: virtual ~automatic_object< T, M >
	// Description	    : 
	// Return type		: 
	virtual ~automatic_object< T, M >()
	{
		if( m_bOwner )
			destroy_object();
	}

	// Asignment operator

	// Function name	: operator = 
	// Description	    : 
	// Return type		: automatic_object< T, M>&
	// Argument         : automatic_object< T, M >& a
	automatic_object< T, M >& operator = ( automatic_object< T, M >& a )
	{
		if( this == &a )
			return *this;

		if( m_bOwner )
			destroy_object();

		m_bOwner = a.m_bOwner;
		a.m_bOwner = false;

		return *this;
	}


	// Function name	: operator = 
	// Description	    : 
	// Return type		: automatic_object< T, M >
	// Argument         : T& t
	automatic_object< T, M >& operator = ( T& t )
	{
		operator()( t );
		return *this;
	}

	// Function name	: T
	// Description	    : Cast operator
	// Return type		: operator 
	operator T()
	{
		return m_Object;
	}

	// Equality operator

	// Function name	: == 
	// Description	    : Equality operator
	// Return type		: bool operator 
	// Argument         : const automatic_object< T, M >& a
	bool operator == ( const automatic_object< T, M >& a )
	{
		return m_Object == a.m_Object;
	}

	// Less than operator

	// Function name	: operator < 
	// Description	    : 
	// Return type		: bool 
	// Argument         : const automatic_object< T, M >& a
	bool operator < ( const automatic_object< T, M >& a )
	{
		return m_Object < a.m_Object;
	}


protected:

	// Object
	T m_Object;

	// Reference count
	bool m_bOwner;

	// Manager
	M m_Manager;

private:


	// Function name	: destroy_object
	// Description	    : 
	// Return type		: void 
	void destroy_object()
	{
		// Destroy the attached object
		m_Manager.delete_object( m_Object );
	}

	// Function name	: init_object
	// Description	    : Object initialization
	// Return type		: void 
	void init_object()
	{
		// Init the attached object
		m_Manager.init_object( m_Object );
		m_bOwner = true;
	}
};


/*
Smart pointer
*/
template< class T >
class s_ptr :
	public reference_counted_object< T*, _pointer_manager< T* > >
{
public:

	// Function name	: s_ptr< T >
	// Description	    : Smart pointer constructor
	// Return type		: 
	// Argument         : T* p = NULL
	s_ptr< T >( T* p = NULL) :
		reference_counted_object< T*, _pointer_manager< T* > >( p )
	{
	}



	s_ptr< T >& operator=( s_ptr< T >& a )
	{
		reference_counted_object< T*, _pointer_manager< T* > >::operator=( a );
		return *this;
	}

	s_ptr< T >& operator=( T* p )
	{
		reference_counted_object< T*, _pointer_manager< T* > >::operator=( p );
		return *this;
	}
	
	// Function name	: operator * 
	// Description	    : 
	// Return type		: T& 
	T& operator*()
	{
		return *m_Object;
	}


	// Function name	: operator -> 
	// Description	    : 
	// Return type		: T*
	T* operator->()
	{
		retrun m_Object;
	}
};

/*
Automatic pointer
*/
template< class T >
class a_ptr :
	public automatic_object< T*, _pointer_manager< T* > >
{
public:

	// Function name	: a_ptr< T >
	// Description	    : Automatic pointer constructor
	// Return type		: 
	// Argument         : T* p = NULL
	a_ptr< T >( T* p = NULL) :
		automatic_object< T*, _pointer_manager< T* > >( p )
	{
	}

	a_ptr< T >( const a_ptr< T >& a ) :
		automatic_object< T*, _pointer_manager< T* > >( *const_cast< a_ptr< T >* >( &a ) )
	{	
	}

	a_ptr< T >& operator=( T* p )
	{
		automatic_object< T*, _pointer_manager< T* > >::operator=( p );
		return *this;
	}

	// Function name	: operator=
	// Description	    : 
	// Return type		: a_ptr< T >&
	// Argument         : a_ptr< T >& a
	a_ptr< T >& operator=( const a_ptr< T >& a )
	{
		automatic_object< T*, _pointer_manager< T* > >::operator=( a );
		return *this;
	}

	// Function name	: operator * 
	// Description	    : 
	// Return type		: 
	T& operator*()
	{
		return *m_Object;
	}


	// Function name	: operator -> 
	// Description	    : 
	// Return type		: 
	T* operator->()
	{
		return m_Object;
	}
};


} // Namespace extension

#endif // ___manage_h__