cel_autoptr.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_autoptr_h_
#define _cel_autoptr_h_

#include "cel_types.h"
#include "cel_exception.h"

namespace Celartem
{
    template<class T> class AutoPtr
    {
    public:
        AutoPtr() : m_ptr(NULL)
        {
        }

        ~AutoPtr()
        {
            setObject(NULL);
        }

        AutoPtr(T* inPtr) : m_ptr(NULL)
        {
            setObject(inPtr);
        }

        template<typename U> AutoPtr(U* inPtr) : m_ptr(NULL)
        {
            setObject((T*)inPtr);
        }
        
        AutoPtr(const AutoPtr& inPtr) : m_ptr(NULL)
        {
            setObject(inPtr.m_ptr);
        }

        template<class U> AutoPtr(const AutoPtr<U>& inPtr) : m_ptr(NULL)
        {
            setObject((T*)inPtr.getPtr());
        }
        
        AutoPtr& operator=(T* inPtr)
        {
            setObject(inPtr);
            return *this;
        }

        template<typename U> AutoPtr& operator=(U* inPtr)
        {
            setObject((T*)inPtr);
            return *this;
        }
        
        AutoPtr& operator=(const AutoPtr& inPtr)
        {
            setObject(inPtr.getPtr());
            return *this;
        }
        
        template<class U> AutoPtr& operator=(const AutoPtr<U>& inPtr)
        {
            setObject((T*)inPtr.getPtr());
            return *this;
        }

        inline bool isValid() const {return m_ptr ? true : false;}

        inline T* getPtr() const {return m_ptr;}

        inline T* operator->() const
        {
            if(_CEL_DEBUG_ && m_ptr == NULL)
                celThrow(errNullPointer);
            return m_ptr;
        }

        inline bool isLastRef() const
        {
            return isValid() && (m_ptr->getReferenceCount() == 1);
        }

        inline operator T* () const {return m_ptr;}

        inline operator AutoPtr<const T>()
        {
            return (const T*)m_ptr;
        }

        void setObject(T* inPtr)
        {
            if(m_ptr == inPtr)  //
                return;

            if(m_ptr) // release the previously referring object
                m_ptr->releaseRef();

            m_ptr = inPtr;
            if(inPtr) // if new object is not NULL, referring it.
                m_ptr->addRef();
        }
        
        void swap(AutoPtr<T>& inPtr)
        {
            if(m_ptr == inPtr)  //
                return;
            
            T* tmp = m_ptr;
            m_ptr = inPtr.m_ptr;
            inPtr.m_ptr = tmp;
        }

        inline void release() {setObject(NULL);}

        inline T* detach()
        {
            T* temp = m_ptr;
            m_ptr = NULL;
            return temp;
        }

    private:
        T* m_ptr;
    };

} // namespace Celartem

#endif // _cel_autoptr_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.