_smart_ptr.h

Go to the documentation of this file.

/* ========================================================================
** Extended Template and Library
** Template Smart Pointer Implementation
** $Id$
**
** Copyright (c) 2002 Robert B. Quattlebaum Jr.
**
** This package 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 package 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.
**
** === N O T E S ===========================================================
**
** This is an internal header file, included by other ETL headers.
** You should not attempt to use it directly.
**
** ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __ETL__SMART_PTR_H
#define __ETL__SMART_PTR_H

/* === H E A D E R S ======================================================= */

#include <cassert>
#include "_ref_count.h"

/* === M A C R O S ========================================================= */

/* === T Y P E D E F S ===================================================== */

/* === C L A S S E S & S T R U C T S ======================================= */

_ETL_BEGIN_NAMESPACE

template <class T>
struct generic_deleter
{
    void operator()(T* x)const { delete x; }
};

template <class T>
struct array_deleter
{
    void operator()(T* x)const { delete [] x; }
};

// ========================================================================
template <class T, class D=generic_deleter<T> >
class smart_ptr
{
public:

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef int count_type;
    typedef int size_type;
    typedef D destructor_type;

#ifdef DOXYGEN_SHOULD_SKIP_THIS     // #ifdef is not a typo
private:
#endif
    value_type *obj;        
    reference_counter refcount;

public:
    // Private constructor for convenience
    smart_ptr(value_type* obj,reference_counter refcount):obj(obj),refcount(refcount) {  }

    smart_ptr():obj(0),refcount(false) {}


    explicit smart_ptr(value_type* x):obj(x),refcount(x?true:false) {  }


#ifdef _WIN32
    template <class U>
    smart_ptr(const smart_ptr<U> &x):obj((pointer)&*x.obj),refcount(x.refcount())
        { }
#endif


    smart_ptr(const smart_ptr<value_type> &x):obj(x.obj),refcount(x.refcount) {  }

    explicit smart_ptr(const value_type &x):obj(new value_type(x)) { }

    ~smart_ptr() { if(refcount.unique()) destructor_type()(obj); }

    template <class U> const smart_ptr<value_type> &
    operator=(const smart_ptr<U> &x)
    {
        if(x.get()==obj)
            return *this;

        reset();

        if(x.obj)
        {
            obj=(pointer)x.get();
            refcount=x.refcount;
        }

        return *this;
    }

    const smart_ptr<value_type> &
    operator=(const smart_ptr<value_type> &x)
    {
        if(x.get()==obj)
            return *this;

        reset();

        if(x.obj)
        {

            obj=(pointer)x.get();
            refcount=x.refcount;
        }

        return *this;
    }

    void
    reset()
    {
        if(obj)
        {
            if(refcount.unique()) destructor_type()(obj);
            refcount.detach();
            obj=0;
        }
    }

    void spawn() { operator=(smart_ptr(new T)); }

    const count_type& count()const { return refcount; }

    bool unique()const { return refcount.unique(); }

    smart_ptr<const value_type> constant() { return *this; }

    reference operator*()const { assert(obj); return *obj; }

    pointer operator->()const { assert(obj); return obj; }


    operator smart_ptr<const value_type>()const
    { return smart_ptr<const value_type>(static_cast<const_pointer>(obj)); }

    template <class U> static
    smart_ptr<T> cast_static(const smart_ptr<U> &x)
    { if(!x)return NULL; return smart_ptr<T>(static_cast<T*>(x.get()),x.refcount); }

    template <class U> static
    smart_ptr<T> cast_dynamic(const smart_ptr<U> &x)
    { if(!x)return 0; return smart_ptr<T>(dynamic_cast<T*>(x.get()),x.refcount); }

    template <class U> static
    smart_ptr<T> cast_const(const smart_ptr<U> &x)
    { if(!x)return 0; return smart_ptr<T>(const_cast<T*>(x.get()),x.refcount); }

    pointer get()const { return obj; }

    operator bool()const { return obj!=0; }

    bool operator!()const { return !obj; }

    template <class U>
    operator smart_ptr<U>()
    {
        // This next line should provide a syntax check
        // to make sure that this cast makes sense.
        // If it doesn't, this should have a compiler error.
        // Otherwise, it should get optimized right out
        // of the code.
        //(U*)obj;

        return *reinterpret_cast<smart_ptr<U>*>(this);
    }

}; // END of template class smart_ptr

// ========================================================================
template <class T>
class loose_smart_ptr
{
public:

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef int count_type;
    typedef int size_type;

private:
    value_type *obj;        
    weak_reference_counter refcount;    

public:

    loose_smart_ptr():obj(0),refcount(0) {}

    loose_smart_ptr(const loose_smart_ptr<value_type> &x):obj(x.get()),refcount(x.refcount) { }

    loose_smart_ptr(const smart_ptr<value_type> &x):obj(x.get()),refcount(x.refcount) { }

    void reset() { obj=0,refcount=0; }

    operator smart_ptr<value_type>()
    {
        return smart_ptr<value_type>(static_cast<pointer>(obj),refcount);
    }

    operator smart_ptr<const value_type>()
    {
        return smart_ptr<const value_type>(static_cast<const_pointer>(obj),refcount);
    }

    const count_type& count()const { return refcount; }

    bool unique()const { return refcount.unique(); }

    reference operator*()const { assert(obj); return *obj; }

    pointer operator->()const { assert(obj); return obj; }

    pointer get()const { return obj; }

    bool operator!()const { return !obj; }
};

template <class T,class U> bool
operator==(const smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
    { return (lhs.get()==rhs.get()); }
template <class T,class U> bool
operator==(const loose_smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
    { return (lhs.get()==rhs.get()); }
template <class T,class U> bool
operator==(const smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
    { return (lhs.get()==rhs.get()); }
template <class T,class U> bool
operator==(const loose_smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
    { return (lhs.get()==rhs.get()); }
template <class T> bool
operator==(const smart_ptr<T> &lhs,const T *rhs)
    { return (lhs.get()==rhs); }
template <class T> bool
operator==(const loose_smart_ptr<T> &lhs,const T *rhs)
    { return (lhs.get()==rhs); }
template <class T> bool
operator==(const T *lhs,const smart_ptr<T> &rhs)
    { return (lhs==rhs.get()); }
template <class T> bool
operator==(const T *lhs,const loose_smart_ptr<T> &rhs)
    { return (lhs==rhs.get()); }


template <class T,class U> bool
operator!=(const smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
    { return (lhs.get()!=rhs.get()); }
template <class T,class U> bool
operator!=(const loose_smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
    { return (lhs.get()!=rhs.get()); }
template <class T,class U> bool
operator!=(const smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
    { return (lhs.get()!=rhs.get()); }
template <class T,class U> bool
operator!=(const loose_smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
    { return (lhs.get()!=rhs.get()); }
template <class T> bool
operator!=(const smart_ptr<T> &lhs,const T *rhs)
    { return (lhs.get()!=rhs); }
template <class T> bool
operator!=(const loose_smart_ptr<T> &lhs,const T *rhs)
    { return (lhs.get()!=rhs); }
template <class T> bool
operator!=(const T *lhs,const smart_ptr<T> &rhs)
    { return (lhs!=rhs.get()); }
template <class T> bool
operator!=(const T *lhs,const loose_smart_ptr<T> &rhs)
    { return (lhs!=rhs.get()); }


template <class T,class U> bool
operator<(const smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
    { return (lhs.get()<rhs.get()); }
template <class T,class U> bool
operator<(const loose_smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
    { return (lhs.get()<rhs.get()); }
template <class T,class U> bool
operator<(const smart_ptr<T> &lhs,const loose_smart_ptr<U> &rhs)
    { return (lhs.get()<rhs.get()); }
template <class T,class U> bool
operator<(const loose_smart_ptr<T> &lhs,const smart_ptr<U> &rhs)
    { return (lhs.get()<rhs.get()); }
template <class T> bool
operator<(const smart_ptr<T> &lhs,const T *rhs)
    { return (lhs.get()<rhs); }
template <class T> bool
operator<(const loose_smart_ptr<T> &lhs,const T *rhs)
    { return (lhs.get()<rhs); }
template <class T> bool
operator<(const T *lhs,const smart_ptr<T> &rhs)
    { return (lhs<rhs.get()); }
template <class T> bool
operator<(const T *lhs,const loose_smart_ptr<T> &rhs)
    { return (lhs<rhs.get()); }

_ETL_END_NAMESPACE

/* === E N D =============================================================== */

#endif