Public Member Functions | Private Attributes

nitro::Pointer< stored_type, memory_handler > Class Template Reference

#include <utilities/pointer.h>

Inherits nitro::PointerInterface.

Collaboration diagram for nitro::Pointer< stored_type, memory_handler >:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 Pointer (void)
 Pointer (std::size_t theItemCount)
 Pointer (const Pointer< stored_type, memory_handler > &Ptr)
Pointer< stored_type,
memory_handler > 		operator= (const Pointer< stored_type, memory_handler > &Ptr)
stored_type & operator[] (std::size_t i)
stored_type * GetBuffer (void)
std::size_t GetBufferSize (void) const
virtual void Allocate (std::size_t theItemCount)
virtual void Release (void)
virtual ~Pointer ()

Private Attributes

stored_type * StoredData

Detailed Description

template<class stored_type, MemoryHandler * memory_handler>
class nitro::Pointer< stored_type, memory_handler >

Class determines pointer type.

Author:
Dodonov A.A.

Definition at line 20 of file pointer.h.

Constructor & Destructor Documentation

template<class stored_type , MemoryHandler * memory_handler>
nitro::Pointer< stored_type, memory_handler >::Pointer ( void   ) 

Constructor.

Author:
Dodonov A.A.

Definition at line 213 of file pointer.h.

        {
        }

template<class stored_type , MemoryHandler * memory_handler>
nitro::Pointer< stored_type, memory_handler >::Pointer ( std::size_t  theItemCount  ) 

Constructor.

Parameters:
theItemCount - Count of elements for wich memory will be allocated.
Author:
Dodonov A.A.

Definition at line 217 of file pointer.h.

References nitro::Pointer< stored_type, memory_handler >::Allocate().

        {
                Allocate( theItemCount );
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
nitro::Pointer< stored_type, memory_handler >::Pointer ( const Pointer< stored_type, memory_handler > &  Ptr  ) 

Private copy constructor.

Parameters:
Ptr - Pointer to copy.
Author:
Dodonov A.A.

Definition at line 222 of file pointer.h.

References nitro::PointerInterface::ItemCount, nitro::Pointer< stored_type, memory_handler >::StoredData, and nitro::exception::what().

        {
                try
                {
                        // const_cast
                        memory_handler->Copy( StoredData , const_cast< char * >( Ptr.StoredData ) );
                        
                        ItemCount = Ptr.ItemCount;
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::Pointer( const Pointer< stored_type , memory_handler > & Ptr )::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::Pointer( const Pointer< stored_type , memory_handler > & Ptr )::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
nitro::Pointer< stored_type, memory_handler >::~Pointer (  )  [virtual]

Destructor.

Author:
Dodonov A.A.

Definition at line 352 of file pointer.h.

References nitro::Pointer< stored_type, memory_handler >::Release().

        {
                try
                {
                        Release();
                }
                catch( nitro::exception e )
                {
                }
                catch( ... )
                {
                }
        }

Here is the call graph for this function:

Member Function Documentation

template<class stored_type , MemoryHandler * memory_handler>
void nitro::Pointer< stored_type, memory_handler >::Allocate ( std::size_t  theItemCount  )  [virtual]

Function allocates memory for theItemCount elements.

Parameters:
theItemCount - Count of elements for wich memory will be allocated.
Exceptions:
nitro::exception Exception of this type is throw. It contains a description of the occured error.
Author:
Dodonov A.A.

Implements nitro::PointerInterface.

Definition at line 309 of file pointer.h.

References nitro::PointerInterface::ItemCount, nitro::Pointer< stored_type, memory_handler >::Release(), nitro::Pointer< stored_type, memory_handler >::StoredData, and nitro::exception::what().

Referenced by nitro::Pointer< stored_type, memory_handler >::Pointer().

        {
                try
                {
                        Release();
                        
                        StoredData = memory_handler->Allocate< stored_type >( this , theItemCount );
                        
                        ItemCount = theItemCount;
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::Allocate( std::size_t theItemCount )::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::Allocate( std::size_t theItemCount )::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
stored_type * nitro::Pointer< stored_type, memory_handler >::GetBuffer ( void   ) 

Function provides access for stored data.

Returns:
Pointer on the stored data.
Exceptions:
nitro::exception Exception of this type is throw. It contains a description of the occured error.
Author:
Dodonov A.A.

Definition at line 277 of file pointer.h.

References nitro::Pointer< stored_type, memory_handler >::StoredData, and nitro::exception::what().

        {
                try
                {
                        return( StoredData );
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::GetBuffer( void )::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::GetBuffer( void )::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
std::size_t nitro::Pointer< stored_type, memory_handler >::GetBufferSize ( void   )  const

Function returns the size of the stored data.

Returns:
Size of the stored buffer.
Exceptions:
nitro::exception Exception of this type is throw. It contains a description of the occured error.
Author:
Dodonov A.A.

Definition at line 293 of file pointer.h.

References nitro::PointerInterface::ItemCount, and nitro::exception::what().

        {
                try
                {
                        return( sizeof( stored_type ) * ItemCount );
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >GetBufferSize( void ) const::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >GetBufferSize( void ) const::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
Pointer< stored_type, memory_handler > nitro::Pointer< stored_type, memory_handler >::operator= ( const Pointer< stored_type, memory_handler > &  Ptr  ) 

Private assign operator.

Parameters:
Ptr - Pointer to copy.
Returns:
*this
Author:
Dodonov A.A.

Definition at line 241 of file pointer.h.

References nitro::PointerInterface::ItemCount, nitro::Pointer< stored_type, memory_handler >::StoredData, and nitro::exception::what().

        {
                try
                {
                        memory_handler->Copy( StoredData , const_cast< char * >( Ptr.StoredData ) );
                        
                        ItemCount = Ptr.ItemCount;
                        
                        return( * this );
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::operator=( const Pointer< stored_type , memory_handler > & Ptr )::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::operator=( const Pointer< stored_type , memory_handler > & Ptr )::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
stored_type & nitro::Pointer< stored_type, memory_handler >::operator[] ( std::size_t  i  ) 

Operator provides access for stored data.

Parameters:
i - Elemet's cursor.
Exceptions:
nitro::exception Exception of this type is throw. It contains a description of the occured error.
Author:
Dodonov A.A.

Definition at line 261 of file pointer.h.

References nitro::Pointer< stored_type, memory_handler >::StoredData, and nitro::exception::what().

        {
                try
                {
                        return( StoredData[ i ] );
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::operator[]( std::size_t i )::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::operator[]( std::size_t i )::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

template<class stored_type , MemoryHandler * memory_handler>
void nitro::Pointer< stored_type, memory_handler >::Release ( void   )  [virtual]

Function deallocates all allocated memory.

Exceptions:
nitro::exception - Exception of this type is throw. It contains a description of the occured error.
Author:
Dodonov A.A.

Implements nitro::PointerInterface.

Definition at line 329 of file pointer.h.

References nitro::PointerInterface::ItemCount, nitro::Pointer< stored_type, memory_handler >::StoredData, and nitro::exception::what().

Referenced by nitro::Pointer< stored_type, memory_handler >::Allocate(), and nitro::Pointer< stored_type, memory_handler >::~Pointer().

        {
                try
                {
                        if( StoredData )
                        {
                                memory_handler->Deallocate( StoredData );
                                
                                StoredData = NULL;
                                
                                ItemCount = NULL;
                        }
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::Release( void )::" ) + e.what() , 0 ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Pointer< stored_type , memory_handler >::Release( void )::An error occured while getting data from pointer" ) , 0 ) );
                }
        }

Here is the call graph for this function:

Member Data Documentation

template<class stored_type, MemoryHandler * memory_handler>
stored_type* nitro::Pointer< stored_type, memory_handler >::StoredData [private]

Pointer on the allocated data.

Author:
Dodonov A.A.

Definition at line 209 of file pointer.h.

Referenced by nitro::Pointer< stored_type, memory_handler >::Allocate(), nitro::Pointer< stored_type, memory_handler >::GetBuffer(), nitro::Pointer< stored_type, memory_handler >::operator=(), nitro::Pointer< stored_type, memory_handler >::operator[](), nitro::Pointer< stored_type, memory_handler >::Pointer(), and nitro::Pointer< stored_type, memory_handler >::Release().

The documentation for this class was generated from the following file:
Generated by  doxygen 1.6.1