base/simpleref.impl

Go to the documentation of this file.

/* **-*-c++-*-**************************************************************
  Copyright (C)2002 David Jung <opensim@pobox.com>

  This program/file 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 program 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. (http://www.gnu.org)
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  $Id: simpleref.impl 1029 2004-02-11 20:45:54Z jungd $
  $Revision: 1.3 $
  $Date: 2004-02-11 15:45:54 -0500 (Wed, 11 Feb 2004) $
  $Author: jungd $
 
****************************************************************************/

#ifndef _BASE_REF_
#define _BASE_REF_


#include <functional>           // for std::less
#include <typeinfo>             // for std::bad_cast
#include <stdexcept>            // for std::runtime_error

namespace base
{
  
  namespace detail
  {
    struct static_cast_tag {};
    struct dynamic_cast_tag {};
  }
  
/// intrusive reference counted smart pointer.  referenced object must
///  implement reference() and unreference() (e.g. class Referenced)
template<typename T>
class ref 
{
public:
  typedef T element_type;
  typedef T* pointer;
  typedef T& reference;

  ref() 
    : p(pointer(0)) 
  {}

  
  explicit ref(pointer p) 
    : p(p)
  {
    if (p) p->reference(); 
  }
  
  
  ref(const ref& r)
    : p(r.p)
  {
    if (p) p->reference();
  }
  
  template<typename T2>
  ref(const ref<T2>& r)
   : p(r.get())
  {
    if (p) p->reference();
  }
  
  
  template<typename T2>
  ref(const ref<T2>& r, detail::static_cast_tag)
  {
    p = static_cast<pointer>(r.get());
    if (p) p->reference();
  }
  
  template<typename T2>
  ref(const ref<T2>& r, detail::dynamic_cast_tag)
  {
    p = dynamic_cast<pointer>(r.get());
    if (r.get() && (!p)) throw std::bad_cast();
    if (p) p->reference();
  }
  
  
  
  ~ref()
  {
    if (p) 
      if (p->unreference())
        delete p;
  }
  
  ref& operator=(const ref& r) 
  { 
    if (&r != this) {
      if (p) 
        if (p->unreference())
          delete p;
      p=r.p; 
      if (p) p->reference();
    }
    return *this; 
  }
  
  template<typename T2>
  ref& operator=(const ref<T2>& r) 
  { 
    if (r.get() != this->get()) {
      if (p) 
        if (p->unreference())
          delete p;
      p=r.get(); 
      if (p) p->reference();
    }
    return *this; 
  }
  
  pointer get() const { return p; }
  
  void reset(pointer p = pointer(0))
  {
    if (p == this->p) {
#ifdef DEBUG
      std::cerr << "can't reset to same pointer\n"; abort();
#else
      throw std::runtime_error("can't reset to same pointer");
#endif
    }
    if (this->p) 
      if (this->p->unreference())
        delete this->p;
    this->p = p;
  }
   
   
  pointer release()
  {
    pointer rp = p;
    if (p) 
      if (p->unreference())
        delete p;
    p = pointer(0);
    return rp;
  }
   
  void swap(ref& r) { std::swap(r.p, p); }
   
  
  bool operator==(const ref& r) const { return p == r.p; }
  bool operator!=(const ref& r) const { return p != r.p; }
  
  template<typename T2>
  bool operator==(const ref<T2>& r) const { return p == r.get(); }
  
  template<typename T2>
  bool operator!=(const ref<T2>& r) const { return p != r.get(); }
  
  template<typename T2>
  bool operator==(const T2* p2) const { return p == p2; }
  
  template<typename T2>
  bool operator!=(const T2* p2) const { return p != p2; }
  
  
  reference operator*() 
  {
    if (!p) {
#ifdef DEBUG
      std::cerr << "null pointer\n"; abort();
#else
      throw std::runtime_error("null pointer");
#endif
    }
    return *p; 
  }
  
  reference operator*() const
  {
    if (!p) {
#ifdef DEBUG
      std::cerr << "null pointer\n"; abort();
#else
      throw std::runtime_error("null pointer");
#endif
    }
    return *p; 
  }
  
  pointer operator->() 
  { 
    if (!p) {
#ifdef DEBUG
      std::cerr << "null pointer\n"; abort();
#else
      throw std::runtime_error("null pointer");
#endif
    }
    return p; 
  }

  pointer operator->() const
  { 
    if (!p) {
#ifdef DEBUG
      std::cerr << "null pointer\n"; abort();
#else
      throw std::runtime_error("null pointer");
#endif
    }
    return p; 
  }
  
  bool operator!() const { return p == 0; }
                                                                                                                                                                                                                                            
private:
    // Helper for enabling 'if (sp)'
    struct Tester
    {
        Tester() {}
    private:
        void operator delete(void*);
    };
    
public:
    // enable 'if (sp)'
    operator Tester*() const
    {
        if (!*this) return 0;
        static Tester t;
        return &t;
    }
  
protected:
  pointer p;
};


template<typename T>
inline void Release(ref<T>& r) { r.release(); }

template<typename T>
inline typename ref<T>::pointer GetImplRef(ref<T>& r) { return r.get(); }

template<typename T>
inline void Reset(ref<T>& r, const typename ref<T>::pointer p) { r.reset(p); }


template<class T, class U> inline bool operator==(const ref<T>& a, const ref<U>& b)
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator==(const T* a, const ref<U>& b)
{
    return a == b.get();
}

template<class T, class U> inline bool operator==(const ref<T>& a, const U* b)
{
    return a.get() == b;
}
                                                                                                                                                                                                                                           
template<class T, class U> inline bool operator!=(const ref<T>& a, const ref<U>& b)
{
    return a.get() != b.get();
}

template<class T, class U> inline bool operator!=(const T* a, const ref<U>& b)
{
    return a != b.get();
}

template<class T, class U> inline bool operator!=(const ref<T>& a, const U* b)
{
    return a.get() != b;
}



template<class T, class U> inline bool operator<(const ref<T>& a, const ref<U>& b)
{
    return a.get() < b.get();
}

template<class T, class U> inline bool operator<(const T* a, const ref<U>& b)
{
    return a < b.get();
}

template<class T, class U> inline bool operator<(const ref<T>& a, const U* b)
{
    return a.get() < b;
}


template<class T, class U> inline bool operator>(const ref<T>& a, const ref<U>& b)
{
    return a.get() > b.get();
}

template<class T, class U> inline bool operator>(const T* a, const ref<U>& b)
{
    return a > b.get();
}

template<class T, class U> inline bool operator>(const ref<T>& a, const U* b)
{
    return a.get() > b;
}



template<class T, class U> inline bool operator<=(const ref<T>& a, const ref<U>& b)
{
    return a.get() <= b.get();
}

template<class T, class U> inline bool operator<=(const T* a, const ref<U>& b)
{
    return a <= b.get();
}

template<class T, class U> inline bool operator<=(const ref<T>& a, const U* b)
{
    return a.get() <= b;
}


template<class T, class U> inline bool operator>=(const ref<T>& a, const ref<U>& b)
{
    return a.get() >= b.get();
}

template<class T, class U> inline bool operator>=(const T* a, const ref<U>& b)
{
    return a >= b.get();
}

template<class T, class U> inline bool operator>=(const ref<T>& a, const U* b)
{
    return a.get() >= b;
}






template<class T, class U> ref<T> static_cast_ref(const ref<U>& r)
{
    return ref<T>(r, detail::static_cast_tag());
}

template<class T, class U> ref<T> narrow_cast_ref(const ref<U>& r)
{
    return ref<T>(r, detail::dynamic_cast_tag());
}
 
template<class T, class U> ref<T> dynamic_cast_ref(const ref<U>& r)
{
    return ref<T>(r, detail::dynamic_cast_tag());
}

#define narrow_ref narrow_cast_ref
  
  
} // base



// specialization of std::less for ref
namespace std
{
  
  template<typename T>
  struct less< base::ref<T> >
    : public binary_function<base::ref<T>, base::ref<T>, bool>
  {
    bool operator()(const base::ref<T>& lhs, const base::ref<T>& rhs) const
    { return less<T*>()(lhs.get(), rhs.get()); }
  };
  
}


#endif

---