base/zz_handle.h

Go to the documentation of this file.

/* libzz
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * Copyright 2000-2006, Toni Thomsson <toni@tonjac.org> 
*/

#ifndef zz_handle_h
#define zz_handle_h

#include <zz_use_counter.h>

/*
    Description:
    Template klass för objekt som allokeras på heapen
    Frigör automatiskt minnet när variabeln går ur scope
    
    Remarks:
    Tillåter inte att allokera sig själv på heapen, skall alltid
    värdekopieras

    Author:  
    Toni Thomsson, toni@tonjac.org

    Library:
    libzz.a (HPUX) libzz.lib (win32)

    Platform:
        HPUX, win32
*/
template< class T > class CzzHandle
{
public:

    /*
        Description: 
        Skapar ett handle objekt

        Remarks:
        Skapar ett handle objekt som kapslar in ett objekt
        som allokerats på heapen

        Example:
        CzzHandle<CxxObject> handle( new CxxObject[ 10 ], true );
        CzzHandle<CxxFoo> foo = new CxxFoo( 1, "kalle" );
        CzzHandle<CxxObject> tmp;

        tmp = handle;
        tmp->callMethod( foo );

        doSomething( tmp );

        // Vi behöver inte frigöra minnet, det sköts automatiskt
        // när variablerna går ur scope

    */
    CzzHandle( T* obj,      // IN, pekare till objekt
                bool vector // IN, vektor eller ej
                ) 
     : m_Object( obj ), m_Counter( new CzzUseCounter() ), 
       m_Vector( vector ) 
    { 
        m_Counter->addRef(); 
    };


    /*
        Description: 
        Skapar ett handle objekt

        Remarks:
        Skapar ett "tomt" objekt, att användas tex. som tmp-variabel
    */
    CzzHandle( void )
     : m_Object( 0 ), m_Counter( 0 ), m_Vector( false ) 
    { 

    };

    /*
        Description: 
        Skapar ett handle objekt

        Remarks:
        Kopieringskonstruktor
    */
    CzzHandle( const CzzHandle& handle  // IN, objekt som skall kopieras
                )
     : m_Object( handle.m_Object ), m_Counter( handle.m_Counter ), 
       m_Vector( handle.m_Vector ) 
    { 
        m_Counter->addRef(); 
    };

    /*
        Description: 
        Skapar ett handle objekt

        Remarks:
        Initierar handle från en pekare
    */
    CzzHandle( T* handle  // IN, pekare som skall hanteras
                )
     : m_Object( handle ), m_Counter( new CzzUseCounter() ), 
       m_Vector( false ) 
    { 
        m_Counter->addRef(); 
    };

    // Description: Frigör kapslat objekt om antalet referenser är noll
    virtual ~CzzHandle()
    {
        if( m_Counter && m_Counter->release() == 0 )
        {
            if( m_Vector )
                delete [] m_Object;
            else
                delete m_Object;

            delete m_Counter;
        }
    };
    
    // Description: Pekare till kapslat objekt
    // Remarks: samma som object()
    T* operator->()
    { 
        return m_Object; 
    };

    // Description: Pekare till kapslat objekt
    // Remarks: samma som operator-> och object()
    operator T*( void )
    {
        return m_Object;
    };

    // Description: Pekare till kapslat objekt
    // Remarks: samma som operator->
    T* object( void )
    {
        return m_Object;
    };

    // Description: Värdet av kapslat objekt
    T value( void )
    { 
        return *m_Object; 
    };

    // Description: Referens till kapslat objekt
    T& ref( void )
    { 
        return *m_Object; 
    };

    // Description: Tilldelningsoperator
    const CzzHandle& operator=( const CzzHandle& handle )
    {
        m_Object = handle.m_Object;
        m_Counter = handle.m_Counter;
        m_Vector = handle.m_Vector;
        m_Counter->addRef();
        return *this;        
    };

protected:

    // Description: Referensräknare
    CzzUseCounter* m_Counter;
    
    // Description: Kapslat objekt
    T* m_Object;

    // Description: Vektor eller ej ?
    bool m_Vector;

private:
    
    // Description: ej tillåtet
    void* operator new( size_t n ) { return 0; };

    // Description: ej tillåtet
        void* operator new[]( size_t n ) { return 0; };

    // Description: ej tillåtet
    void operator delete( void*, size_t n ) { };

    // Description: ej tillåtet
    void operator delete[]( void*, size_t n ) { };
};

#endif // zz_handle_h

---