SHRPtr.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */

#ifndef SH_REPORT_RPTR_H
#define SH_REPORT_RPTR_H

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

#include "MNValid.h"

namespace SH
{

template <class T>
class RPtr
{
public:
    RPtr( )
        : _pointee( NULL )
    {
    }

    explicit RPtr( T* pointee )
        : _pointee( pointee )
    {
        if( pointee != NULL )
        {
            pointee->ref();
        }
    }

    RPtr( const RPtr& other )
        : _pointee( other._pointee )
    {
        if( _pointee ) _pointee->ref();
    }

    RPtr& operator=( const RPtr& other )
    {
        if( _pointee ) _pointee->unref();
        _pointee = other._pointee;
        if( _pointee ) _pointee->ref();
        return *this;
    }

    RPtr& operator=( T* pointee )
    {
        if( _pointee ) _pointee->unref();
        _pointee = pointee;
        if( _pointee ) _pointee->ref();
        return *this;
    }

    ~RPtr( )
    {
        if( _pointee ) _pointee->unref();
    }

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

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

    T* pointer() const
    {
        return _pointee;
    }

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

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

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

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

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

private:
    T*              _pointee;
};

}; // namespace SH

#endif /* SH_REPORT_RPTR_H */

---