GCPtr.h

Go to the documentation of this file.

/* Copyright (C) 2002 Carsten Griwodz
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, this code may be used in unmodified form
 * provided that this copyright notice and this permission notice appear
 * in supporting documentation.
 *
 * The code may be made subject to the terms of the GNU General Public
 * License, Version 2, and re-distributed under the terms of this license.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after negotiation of conditions with the authors.
 */
#ifndef OS_GC_PTR_H
#define OS_GC_PTR_H

#include <stdio.h>
#include <assert.h>

namespace OS
{

template <class T>
class GCPtr
{
public:
    GCPtr( )
        : _pointee( NULL )
        , _copies( NULL )
    {
    }

    explicit GCPtr( T* pointee )
        : _pointee( pointee )
        , _copies( NULL )
    {
        if( pointee != NULL )
        {
            _copies = new size_t;
            *_copies = 1;
        }
    }

    GCPtr( const GCPtr& other )
        : _pointee( NULL )
        , _copies( NULL )
    {
        copy( other );
    }

    GCPtr& operator=( const GCPtr& other )
    {
        reduce( );
        copy( other );
        return *this;
    }

    GCPtr& operator=( T* pointee )
    {
        reduce( );
        _pointee = pointee;
        if( pointee != NULL )
        {
            _copies = new size_t;
            *_copies = 1;
        }
        return *this;
    }

    ~GCPtr( )
    {
        reduce( );
    }

    T& operator*( ) const
    {
        return *_pointee;
    }

    T* operator->( ) const
    {
        return _pointee;
    }

    inline bool isNull( ) const {
        assert( isConsistent() );
        return ( _pointee == NULL );
    }

private:
    bool operator==( T* pointee )
    {
        return ( _pointee == pointee );
    }

    bool operator!=( T* pointee )
    {
        return ( _pointee != pointee );
    }

    bool operator==( const GCPtr& other )
    {
        return ( _pointee == other._pointee );
    }

    bool operator!=( const GCPtr& other )
    {
        return ( _pointee != other._pointee );
    }

    bool isConsistent( ) const
    {
        if( _pointee == NULL && _copies == NULL ) return true;
        if( _pointee != NULL && _copies != NULL ) return true;
        return false;
    }

private:
    T*              _pointee;
    mutable size_t* _copies;

private:
    void copy( const GCPtr& other )
    {
       _pointee = other._pointee;
       _copies  = other._copies;
       if( _copies )
       {
           *_copies += 1;
       }
    }

    void reduce( )
    {
        assert( isConsistent() );
        if( _copies )
        {
            assert( *_copies > 0 );
            *_copies -= 1;
            if( *_copies == 0 )
            {
                delete _pointee;
                delete _copies;
                _copies = NULL;
                _pointee = NULL;
            }
        }
        else
        {
            _pointee = NULL;
        }
    }
};

}; // namespace OS

#endif /* OS_GC_PTR_H */

---