smartptr.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2014> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
/*
 *
 */
 
#ifndef TY_SMARTPTR
#define TY_SMARTPTR
 
#if _MSC_VER > 1000
    #pragma once
#endif // _MSC_VER > 1000
 
#ifdef _MSC_VER
    #pragma warning(disable : 4284)
#endif
 
#ifdef _MSC_VER
    #pragma warning(disable : 4786)
#endif
 
class IRefCount
{
public:
    IRefCount() : m_refCount(0){};
    virtual ~IRefCount() {}
 
    virtual int incRef()
    {
        return m_refCount++;
    };
 
    virtual int decRef()
    {
        --m_refCount;
        if (!m_refCount)
        {
            delete this;
            return 0;
        }
        return m_refCount;
    };
 
    int getRefCount() const
    {
        return m_refCount;
    }
 
protected:
    int m_refCount;
};
 
template <class T> class SmartPtr
{
public:
    SmartPtr()
    {
        _pObj = 0;
    }
    SmartPtr(T* pObj)
    {
        _pObj = pObj;
        if (_pObj != 0)
        {
            _pObj->incRef();
        }
    }
    template <class U> SmartPtr(const SmartPtr<U>& ptr)
    {
        _pObj = ptr._pObj;
        if (_pObj != 0)
        {
            _pObj->incRef();
        }
    }
    SmartPtr(const SmartPtr& ptr)
    {
        _pObj = ptr._pObj;
        if (_pObj != 0)
        {
            _pObj->incRef();
        }
    }
 
    ~SmartPtr()
    {
        if (_pObj != 0)
        {
            if (!_pObj->decRef())
            {
                _pObj = 0;
            }
        }
    }
 
    operator T*() const
    {
        return _pObj;
    }
    T& operator*()
    {
        return *_pObj;
    }
 
    T* operator->() const
    {
        return _pObj;
    }
 
    template <class U> SmartPtr& operator=(const SmartPtr<U>& ptr)
    {
        if (_pObj != ptr._pObj)
        {
            if (_pObj != 0)
            {
                _pObj->decRef();
            }
 
            _pObj = ptr._pObj;
 
            if (_pObj != 0)
            {
                _pObj->incRef();
            }
        }
 
        return *this;
    }
 
    SmartPtr& operator=(const SmartPtr& ptr)
    {
        *this = ptr._pObj;
        return *this;
    }
 
    SmartPtr& operator=(T* pObj)
    {
        if (pObj != 0)
        {
            pObj->incRef();
        }
 
        if (_pObj != 0)
        {
            _pObj->decRef();
        }
 
        _pObj = pObj;
        return *this;
    };
 
    bool operator==(const SmartPtr& ptr) const
    {
        return _pObj == ptr._pObj;
    }
 
    bool operator==(T* pObj) const
    {
        return _pObj == pObj;
    }
 
    bool operator!=(const SmartPtr& ptr) const
    {
        return _pObj != ptr._pObj;
    }
 
    bool operator!=(T* pObj) const
    {
        return _pObj != pObj;
    }
 
    bool operator>(const SmartPtr& ptr) const
    {
        return _pObj > ptr._pObj;
    }
    bool operator>(T* pObj) const
    {
        return _pObj > pObj;
    }
 
    bool operator<(const SmartPtr& ptr) const
    {
        return _pObj < ptr._pObj;
    }
    bool operator<(T* pObj) const
    {
        return _pObj < pObj;
    }
 
    T* getRealPointer()
    {
        return _pObj;
    }
    const T* getRealPointer() const
    {
        return _pObj;
    }
 
    // Members
public:
    T* _pObj;
};
 
#endif // TY_SMARTPTR