/home/vlg/develop/libASSA/libassa/assa/AutoPtr.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                               AutoPtr.h
//------------------------------------------------------------------------------
//  Copyright (C) 1999,2005  Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version. 
//------------------------------------------------------------------------------
#ifndef AUTO_PTR_H
#define AUTO_PTR_H

#include <cstdlib>              // NULL definition

namespace ASSA {

template<typename R> class AutoPtrRef {
public:
    explicit AutoPtrRef (R* p_) : m_ptr (p_) { /* no-op */ }
    
    R* m_ptr;
};
 
template<class X> class AutoPtr {
private:
    X* m_ptr;

public:
    explicit AutoPtr (X* p_ = 0) : m_ptr (p_) { /* no-op */ }

    AutoPtr (AutoPtr& a_) : m_ptr (a_.release ()) {/* no-op */ }

    template<typename T> 
    AutoPtr (AutoPtr<T>& a_) : m_ptr (a_.release ()) { /* no-op */ }

    AutoPtr& operator= (AutoPtr& a_)  {
        reset (a_.release ());
        return *this;
    }

    template<class T> AutoPtr& operator=(AutoPtr<T>& a_) {
        reset (a_.release ());
        return *this;
    }

    ~AutoPtr () { 
        if (m_ptr) { 
            delete m_ptr; 
        }  
    }
    
    X& operator*() const  { return *m_ptr; }

    X* operator->() const  { return m_ptr; }
    
    X* get () const { return m_ptr; }

    X* release () {
        X* tmp = m_ptr;
        m_ptr = NULL;
        return tmp;
    }
    
    void reset (X* p_ = 0) {
        if (p_ != m_ptr) {
            delete m_ptr;
            m_ptr = p_;
        }
    }

    AutoPtr (AutoPtrRef<X> ref_) : m_ptr (ref_.m_ptr) { /* no-op */ }

    AutoPtr& operator=(AutoPtrRef<X> ref_) {
        if (ref_.m_ptr != get ()) {
            delete m_ptr;
            m_ptr = ref_.m_ptr;
        }
        return *this;
    }
    
    template<typename T>
    operator AutoPtrRef<T> () { return AutoPtrRef<T> (release ()); }

    template<typename T>
    operator AutoPtr<T> () { return AutoPtr<T> (release ()); }
    
};

template<typename R> class AutoPtrArrayRef {
public:
    explicit AutoPtrArrayRef (R* p_) : m_ptr (p_) { /* no-op */ }
    
    R* m_ptr;
};

template<class X> class AutoPtrArray {
private:
    X* m_ptr;

public:
    explicit AutoPtrArray (X* p_ = 0) : m_ptr (p_) { /* no-op */ }

    AutoPtrArray (AutoPtrArray& a_) : m_ptr (a_.release ()) {/* no-op */ }

    template<typename T> 
    AutoPtrArray (AutoPtrArray<T>& a_) 
        : m_ptr (a_.release ()) { /* no-op */ }

    AutoPtrArray& operator= (AutoPtrArray& a_)  {
        reset (a_.release ());
        return *this;
    }

    template<class T> 
    AutoPtrArray& operator=(AutoPtrArray<T>& a_) {
        reset (a_.release ());
        return *this;
    }

    ~AutoPtrArray () { 
        if (m_ptr) { 
            delete [] m_ptr; 
        }  
    }
    
    X& operator*() const  { return *m_ptr; }

    X* operator->() const  { return m_ptr; }

    X& operator[] (int i) const {
        X* array = get ();
        return (array [i]);
    }
    
    X* get () const  { return m_ptr; }

    X* release () {
        X* tmp = m_ptr;
        m_ptr = NULL;
        return tmp;
    }
    
    void reset (X* p_ = 0) {
        if (p_ != m_ptr) {
            delete [] m_ptr;
            m_ptr = p_;
        }
    }

    AutoPtrArray (AutoPtrArrayRef<X> ref_) : m_ptr (ref_.m_ptr) { /* no-op */ }

    AutoPtrArray& operator=(AutoPtrArrayRef<X> ref_) {
        if (ref_.m_ptr != get ()) {
            delete [] m_ptr;
            m_ptr = ref_.m_ptr;
        }
        return *this;
    }
    
    template<typename T>
    operator AutoPtrArrayRef<T> () { return AutoPtrArrayRef<T> (release ()); }

    template<typename T>
    operator AutoPtrArray<T> () { return AutoPtrArray<T> (release ()); }
    
};

} // end namespace ASSA

#endif /* AUTO_PTR_H */

---