utilities/shared_pointer.h

Go to the documentation of this file.

#ifndef         __SHARED_POINTER_H__
#define         __SHARED_POINTER_H__

#include        <utilities/allocator.h>

namespace       nitro
{

        class                                                                           SharedPointerInterface{
        
        public:
        
                virtual ~SharedPointerInterface(){};

                virtual void *                                                          GetDataAddress( void ) = 0;
        };
        
        template< class managed_type >class                     SharedPointer : public SharedPointerInterface{
        public:

                SharedPointer( void );

                SharedPointer( managed_type * p );

                SharedPointer( const SharedPointer & p );

                void                                                                            Reset( managed_type * p );

                SharedPointer< managed_type >                           operator=( const SharedPointer< managed_type > & p );

                managed_type *                                                          GetData( void );

                virtual void *                                                          GetDataAddress( void );

                managed_type *                                                          operator->( void );

                managed_type &                                                          operator*( void );

                                                                                                        operator managed_type * ( void );

                virtual ~SharedPointer();

        private:

                int *                                                                           ReferenceCounter;

                managed_type *                                                          Data;

                void                                                                            Release( void );

                nitro::Allocator *                                                      DefaultAllocator;

        };

        template< class managed_type >SharedPointer< managed_type >::SharedPointer( void )
        {
                DefaultAllocator = nitro::GetAllocator();
                ReferenceCounter = new int;
                * ReferenceCounter = 1;
                Data = DefaultAllocator->AllocateBlock();
        }

        template< class managed_type >SharedPointer< managed_type >::SharedPointer( managed_type * p )
        {
                DefaultAllocator = nitro::GetAllocator();
                ReferenceCounter = new int;
                * ReferenceCounter = 1;
                Data = p;
        }

        template< class managed_type >SharedPointer< managed_type >::SharedPointer( const SharedPointer & p )
        {
                DefaultAllocator = nitro::GetAllocator();
                ReferenceCounter = p.ReferenceCounter;
                Data = p.Data;
                ( * ReferenceCounter )++;
        }

        template< class managed_type >void                                                      SharedPointer< managed_type >::Reset( managed_type * p )
        {
                Release();

                ReferenceCounter = new int;
                * ReferenceCounter = 1;
                Data = p;
        }

        template< class managed_type >SharedPointer< managed_type >     SharedPointer< managed_type >::operator=( const SharedPointer< managed_type > & p )
        {
                if( this != & p )
                {
                        Release();

                        ReferenceCounter = p.ReferenceCounter;
                        Data = p.Data;
                        ( * ReferenceCounter )++;
                }

                return( * this );
        }

        template< class managed_type >managed_type *                            SharedPointer< managed_type >::GetData( void )
        {
                return( Data );
        }

        template< class managed_type >void *                                            SharedPointer< managed_type >::GetDataAddress( void )
        {
                return( ( void * )Data );
        }

        template< class managed_type >managed_type *                            SharedPointer< managed_type >::operator->( void )
        {
                return( Data );
        }

        template< class managed_type >managed_type &                            SharedPointer< managed_type >::operator*( void )
        {
                return( * Data );
        }

        template< class managed_type >                                                          SharedPointer< managed_type >::operator managed_type * ( void )
        {
                return( Data );
        }

        template< class managed_type >/* virtual */ SharedPointer< managed_type >::~SharedPointer()
        {
                Release();
        }

        template< class managed_type >void                                                      SharedPointer< managed_type >::Release( void )
        {
                if( * ReferenceCounter == 1 )
                {
                        delete ReferenceCounter;
                        ReferenceCounter = 0;

                        //delete Data;
                        DefaultAllocator->DeallocateBlock( Data );
                        Data = 0;
                }
                else
                {
                        ( * ReferenceCounter )--;
                }
        }
}

#endif