it_cal/auto_ptr.h

#ifndef _IT_CAL_AUTO_PTR_H_
#define _IT_CAL_AUTO_PTR_H_

// ******************************************************************
//
//
//        Copyright (c) 1993-2004 IONA Technologies PLC.
//                       All Rights Reserved.
//
//
// ******************************************************************



//
// REVISIT: all this should probably move to dsa/auto_ptr
//

#include <it_cal/cal.h>

// for ptrdiff_t
//
#include <stddef.h>


#if IT_HAS_STANDARD_HEADERS && IT_HAS_AUTO_PTR

#include <memory>

#if IT_HAS_NAMESPACE_STD

#define IT_AutoPtr std::auto_ptr

#else  

#define IT_AutoPtr auto_ptr

#endif 

#else  

template<class T>
class IT_AutoPtr
{
  public:

    IT_EXPLICIT
    IT_AutoPtr(
        T* ptr = 0
    ) IT_THROW_DECL(()) :
        m_ptr(ptr)
    {}
    
    IT_AutoPtr(
        const IT_AutoPtr<T>& other
    )  IT_THROW_DECL(()) :
        m_ptr(
            (IT_CONST_CAST(IT_AutoPtr<T>&, other)).release()
        )
    {}

    ~IT_AutoPtr() IT_THROW_DECL(())
    {
        delete m_ptr;
    }
    
    IT_AutoPtr<T>&
    operator=(
        const IT_AutoPtr<T>& rhs
    )  IT_THROW_DECL(())
    {
        reset((IT_CONST_CAST(IT_AutoPtr<T>&, rhs)).release());
        return *this;
    }
    
    T&
    operator*() const IT_THROW_DECL(())
    {
        return *m_ptr;
    }
    
    T*
    operator->() const IT_THROW_DECL(())
    {
        return m_ptr;
    }

    T*
    get() const IT_THROW_DECL(())
    {
        return m_ptr;
    }

    T*
    release() IT_THROW_DECL(())
    {
        T* tmp = m_ptr;
        m_ptr = 0;
        return tmp;
    }

    void
    reset(
        T* ptr = 0
    )  IT_THROW_DECL(())
    {
        delete m_ptr;
        m_ptr = ptr;
    }
 
  private:
    
    T* m_ptr;
};


#endif 



template<class T>
class IT_AutoArrayPtr
{
  public:

    IT_EXPLICIT
    IT_AutoArrayPtr(
        T* ptr = 0
    ) IT_THROW_DECL(()) :
        m_ptr(ptr)
    {}
    
    IT_AutoArrayPtr(
        const IT_AutoArrayPtr<T>& other
    )  IT_THROW_DECL(()) :
        m_ptr(
            (IT_CONST_CAST(IT_AutoArrayPtr<T>&, other)).release()
        )
    {}

    ~IT_AutoArrayPtr() IT_THROW_DECL(())
    {
        delete [] m_ptr;
    }
    
    IT_AutoArrayPtr<T>&
    operator=(
        const IT_AutoArrayPtr<T>& rhs
    )  IT_THROW_DECL(())
    {
        reset((IT_CONST_CAST(IT_AutoArrayPtr<T>&, rhs)).release());
        return *this;
    }

    T&
    operator[](
        ptrdiff_t i
    ) const IT_THROW_DECL(())
    {
        return m_ptr[i];
    }
    
    T&
    operator*() const IT_THROW_DECL(())
    {
        return *m_ptr;
    }

    T*
    get() const IT_THROW_DECL(())
    {
        return m_ptr;
    }

    T*
    release() IT_THROW_DECL(())
    {
        T* tmp = m_ptr;
        m_ptr = 0;
        return tmp;
    }

    void
    reset(
        T* ptr = 0
    )  IT_THROW_DECL(())
    {
        delete[] m_ptr;
        m_ptr = ptr;
    }
 
  private:
    
    T* m_ptr;
};


template<class T, class R>
class IT_ExtendedAutoPtr
{
    typedef ::IT_ExtendedAutoPtr<T,R>& _ref_type;
  public:

    IT_EXPLICIT
    IT_ExtendedAutoPtr(
        T* ptr = 0
    ) IT_THROW_DECL(()) :
        m_ptr(ptr)
    {}
    
    IT_ExtendedAutoPtr(
        const IT_ExtendedAutoPtr<T,R>& other
    )  IT_THROW_DECL(()) :
        m_ptr(
            (IT_CONST_CAST(_ref_type, other)).release()
        )
    {}

    ~IT_ExtendedAutoPtr() IT_THROW_DECL(())
    {
        R::release(m_ptr);
    }
    
    IT_ExtendedAutoPtr<T,R>&
    operator=(
        const IT_ExtendedAutoPtr<T,R>& rhs
    )  IT_THROW_DECL(())
    {
        reset((IT_CONST_CAST(_ref_type, rhs)).release());
        return *this;
    }
    
    T&
    operator*() const IT_THROW_DECL(())
    {
        return *m_ptr;
    }
    
    T*
    get() const IT_THROW_DECL(())
    {
        return m_ptr;
    }

    T*
    release() IT_THROW_DECL(())
    {
        T* tmp = m_ptr;
        m_ptr = 0;
        return tmp;
    }

    void
    reset(
        T* ptr = 0
    )  IT_THROW_DECL(())
    {
        R::release(m_ptr);
        m_ptr = ptr;
    }
 
  private:
    
    T* m_ptr;
};



#endif  

---