reference-count.h

Go to the documentation of this file.

#ifndef __loaded__reference_count_h__
#define __loaded__reference_count_h__
using namespace std;
#line 1 "reference-count.h++"
#include <assert.h>
#ifndef SINGLE_THREADED
#include "cmpxchg.h"
#endif

//#define SINGLE_THREADED
class ReferenceCount
{
 public:
  volatile int reference_count;
  ReferenceCount(): reference_count(0)
  {
  }
  ReferenceCount(const ReferenceCount&): reference_count(0)
  {
  }
  ReferenceCount& operator =(const ReferenceCount& o)
  {
    assert(&o!=this);
    reference_count=0;
    return *this;
  }
  void incref() 
  {
#ifdef SINGLE_THREADED
    assert(reference_count>=0);
    reference_count++;
#else
    int before;
    do 
      {
        before = reference_count;
      }
    while(cmpxchg(&reference_count,before,before+1)!=before);
    assert(before>=0);
#endif
  }
  int decref()
  {
#ifdef SINGLE_THREADED
    return --reference_count;
#else
    int before;
    do 
      {
        before = reference_count;
      }
    while(cmpxchg(&reference_count,before,before-1)!=before);
    return before-1;
#endif
  }
  virtual ~ReferenceCount()
  {
    assert(reference_count==-1);
  }
};

template <class ReferenceCountedObject> 
class Smart
{
public:
  ReferenceCountedObject* ptr;
  void incref() const
  {
    if (ptr)
      ptr->incref();
  }
  void decref() const
  {
    if (ptr && ptr->decref()==0)
      {
        ptr->decref();
        delete ptr;
      }
  }
 public:
  explicit Smart(ReferenceCountedObject* p = 0) : ptr(p)
  {
    incref();
  }
  Smart(const Smart<ReferenceCountedObject>& o) : ptr(o.ptr)
  {
    incref();
  }
  Smart<ReferenceCountedObject>& operator=(const Smart<ReferenceCountedObject>&o)
  {
    o.incref();
    decref();
    ptr=o.ptr;
    return *this;
  }
  template <class AnotherReferenceCountedObject>
  Smart<ReferenceCountedObject>& operator=(const Smart<AnotherReferenceCountedObject>&o)
  {
    o.incref();
    decref();
    ptr=(ReferenceCountedObject*)o.ptr;
    return *this;
  }

  bool operator==(const Smart<ReferenceCountedObject>&o) const
    {
      return ptr==o.ptr;
    }
  bool operator!=(const Smart<ReferenceCountedObject>&o) const
    {
      return ptr!=o.ptr;
    }
  bool operator<(const Smart<ReferenceCountedObject>&o) const
    {
      return ptr<o.ptr;
    }
  bool operator<=(const Smart<ReferenceCountedObject>&o) const
    {
      return ptr<=o.ptr;
    }
  bool operator>=(const Smart<ReferenceCountedObject>&o) const
    {
      return ptr>=o.ptr;
    }
  ~Smart()
    {
      decref();
    }
  ReferenceCountedObject& operator*()
    {
      return *ptr;
    }
  ReferenceCountedObject* operator->()
    {
      return ptr;
    }
  operator bool()
    {
      return ptr;
    }
  template <class AnotherReferenceCountedObject> 
  operator Smart<AnotherReferenceCountedObject>()
  {
    return Smart<AnotherReferenceCountedObject>((AnotherReferenceCountedObject*)ptr);
  }
};
#endif // __loaded__reference_count_h__

---