autoptr.h

Go to the documentation of this file.

#ifndef AUTOPTR_H
#define AUTOPTR_H
#include <assert.h>

namespace GMapping{

template <class X>
class autoptr{
        protected:
        
        public:
        struct reference{
                X* data;
                unsigned int shares;
        };
                inline autoptr(X* p=(X*)(0));
                inline autoptr(const autoptr<X>& ap);
                inline autoptr& operator=(const autoptr<X>& ap);
                inline ~autoptr();
                inline operator int() const;
                inline X& operator*();
                inline const X& operator*() const;
                //p     
                reference * m_reference;
        protected:
};

template <class X>
autoptr<X>::autoptr(X* p){
        m_reference=0;
        if (p){
                m_reference=new reference;
                m_reference->data=p;
                m_reference->shares=1;
        }
}

template <class X>
autoptr<X>::autoptr(const autoptr<X>& ap){
        m_reference=0;
        reference* ref=ap.m_reference;
        if (ap.m_reference){
                m_reference=ref;
                m_reference->shares++;
        }
}

template <class X>
autoptr<X>& autoptr<X>::operator=(const autoptr<X>& ap){
        reference* ref=ap.m_reference;
        if (m_reference==ref){
                return *this;
        }
        if (m_reference && !(--m_reference->shares)){
                delete m_reference->data;
                delete m_reference;
                m_reference=0;
        }       
        if (ref){
                m_reference=ref;
                m_reference->shares++;
        } 
//20050802 nasty changes begin
        else
                m_reference=0;
//20050802 nasty changes end
        return *this;
}

template <class X>
autoptr<X>::~autoptr(){
        if (m_reference && !(--m_reference->shares)){
                delete m_reference->data;
                delete m_reference;
                m_reference=0;
        }       
}

template <class X>
autoptr<X>::operator int() const{
        return m_reference && m_reference->shares && m_reference->data;
}

template <class X>
X& autoptr<X>::operator*(){
        assert(m_reference && m_reference->shares && m_reference->data);
        return *(m_reference->data);
}

template <class X>
const X& autoptr<X>::operator*() const{
        assert(m_reference && m_reference->shares && m_reference->data);
        return *(m_reference->data);
}

};
#endif