---

ref.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef REF_H_HAS_BEEN_INCLUDED
#define REF_H_HAS_BEEN_INCLUDED

#include <assert.h>
#include "std/config.H"
#include "std/thread_mutex.H"
#ifdef _AIX
#include <sys/atomic_op.h>
#endif
#ifdef sgi
#include <limits.h>
#include <mutex.h>
#endif

// AIX compiler seems to create a macro called Free(p), so this is necessary
#ifdef Free
#undef Free
#endif

#define REF_CLASS(FOO)  FOO; typedef REFptr<FOO> FOO##ptr; class FOO
#define FD_REF_CLASS(FOO)  FOO; typedef REFptr<FOO> FOO##ptr
// I don't think this can be replaced w/ a typedef since REFptr is typedef'd
#define cREFptr const REFptr

#define REF_ME(A)   ((REFcounter *)A)
/*
** reference-counting base or mix-in class
*/

class REFcounter {
 private:
   union  {
      struct {
// Endian differences strike again
// XXX - assumes WIN32 only on i386 boxes
#if defined(WIN32) || defined(i386)
       unsigned int _ref:31;
       unsigned int _lock:1;
#else
       unsigned int _lock:1;
       unsigned int _ref:31;
#endif
     } _a;
     unsigned int _all;
  } _u;
   ThreadMutex _mutex;
 
 public:
            REFcounter()             { _u._all = 0; }
   virtual ~REFcounter()             { }
   void     Own()          const     {
#ifdef _AIX
      fetch_and_add((int *) &REF_ME(this)->_u._all, 1);
#elif defined(sgi)
      test_then_add((unsigned long *) &REF_ME(this)->_u._all, 1);
#else
#ifdef USE_PTHREAD
      CriticalSection cs((ThreadMutex*)&_mutex);
#endif
      REF_ME(this)->_u._a._ref++;
#endif
   }
            // need to lock ourself before calling delete since the destructor
            // may make a local REFptr to itself.  When the REFptr goes out of
            // scope, Free() gets called again leading to an infinite loop.
   void     Free()         const     {
      // If new value is 0...
#if defined(_AIX)
      if (fetch_and_add((int *) &REF_ME(this)->_u._all, -1) == 1)
#elif defined(sgi)
      // hack to do atomic decrement
      if (test_then_add((unsigned long *) &REF_ME(this)->_u._all, UINT_MAX)==1)
#else
#ifdef USE_PTHREAD
      CriticalSection cs((ThreadMutex*)&_mutex);
#endif
      if (--REF_ME(this)->_u._all == 0)
#endif
         {
#if !defined(_AIX) && !defined(sgi)
            ((ThreadMutex*)&_mutex)->unlock();
#endif
            REF_ME(this)->Lock();
#if !defined(_AIX) && !defined(sgi)
            ((ThreadMutex*)&_mutex)->lock();
#endif
            delete REF_ME(this); 
         }
   }
   int      Lock()                   { CriticalSection cs(&_mutex);
                                       int old = _u._a._lock; _u._a._lock = 1; 
                                       return old; }
   void     Unlock()                 { CriticalSection cs(&_mutex);
                                       _u._a._lock = 0; }
   int      Unique()       const     { CriticalSection cs((ThreadMutex*)&_mutex);
                                       return _u._a._ref == 1; }
};

class REFlock {
      REFcounter *_ref;
      int         _old;
   public :
      REFlock(REFcounter *r):_ref(r) { _old = _ref->Lock(); }
     ~REFlock()                      { if (!_old) _ref->Unlock(); }
};


/*
** reference-counted shared pointer
*/

template <class T>
class REFptr {
 protected:
   T * p_;
 public:
   REFptr(             ): p_(0)             { }
   REFptr(cREFptr<T> &p): p_(p.p_)          { if (p_) REF_ME(p_)->Own (); }
   REFptr(T *      pObj): p_(pObj)          { if (p_) REF_ME(p_)->Own (); }

   // The following should be virtual, but if so, Sun CC gives warnings about
   // str_ptr::operator== hiding REFptr<STR>::operator==(const REFptr<STR>&)
#if !defined(sun)
   virtual
#endif
   ~REFptr()                                { if (p_) REF_ME(p_)->Free(); }

   void      Init        ()                 { p_ = 0; }
   void      Clear       ()                 { if (p_) REF_ME(p_)->Free(); p_=0;}

   REFptr<T> &operator =  (T *      o)       { if (o    != p_) {
                                                 if (o) REF_ME(o)->Own(); 
                                                 Clear();  
                                                 p_ = o; 
                                              }    
                                              return *this; }
   REFptr<T> &operator =  (cREFptr<T>& p)    { if (p.p_ != p_) {
                                                 if (p.p_) REF_ME(p.p_)->Own();
                                                 Clear();  
                                                 p_ = p.p_; 
                                              } 
                                              return *this; }

   bool      operator == (cREFptr<T>& p) const {           return  p.p_ == p_; }
   bool      operator != (cREFptr<T>& p) const {           return  p.p_ != p_; }

   int       operator !  ()              const {           return !p_; }

   const T & operator *  ()              const { assert(p_);  return *p_; }
         T & operator *  ()                    { assert(p_);  return *p_; }
   const T * operator -> ()              const { assert(p_);  return  p_; }
         T * operator -> ()                    { assert(p_);  return  p_; }

             operator int()              const {              return  (int)p_;}
   T         *pointer()                  const { return p_; }
   T         *&pointer()                       { return p_; }

   REFptr<T> &Cast_from_void(void *V)        { *this = (T *) V; return *this; }
   friend ostream& operator<<(ostream& os,cREFptr<T>& p) { return os << p.p_; }
};

#undef REF_ME



// This macro makes a REFptr baseclass that other
// REFptr templates can subclass from.  The key to 
// allowing subclassing is the definition of the subc
// class which defines a virtual cast function.  The
// derived REFptr classes will have to define a subclass
// of the subc class and fill in the cast function with
// something that can return the subclass type.
//
#define MAKE_PTR_BASEC(A)             \
class A;                              \
class A##subc {                       \
   public :                           \
      virtual A *A##cast() const = 0; \
};                                    \
typedef const class A##ptr c##A##ptr; \
class A##ptr : public REFptr<A>, public A##subc {  \
   public :                                        \
     A##ptr()                                   { }\
     A##ptr(A             *g): REFptr<A>(g)     { }\
     A##ptr(const A##ptr  &p): REFptr<A>(p.p_)  { }\
     A##ptr(const A##subc &p): REFptr<A>(p.A##cast()) { } \
                                                   \
    virtual A *A##cast() const { return p_; } \
}


// this macro is used to define a REFptr subclass from another
// templated REFptr.  We can't use normal inheritance because
// we want the subclassed pointer to return different template
// types than the parent pointer for all of the derefrencing
// functions.  Thus we define the subclass pointer to multiply
// inherit from its template defintion and from a "hack" subc
// class for the parent.  In addition, this macro defines a
// "hack" subc class for the subclassed pointer so that other
// ptr classes can in turn subclass from it.
//
#define MAKE_PTR_SUBC(A,B) \
class A; \
class A##subc: public B##subc  {  \
   public :  \
      virtual A *A##cast() const = 0; \
      virtual B *B##cast() const { return (B *)A##cast(); } \
}; \
typedef const class A##ptr c##A##ptr; \
class A##ptr : public REFptr<A>, public A##subc {  \
   public :                                        \
     A##ptr()                                   { }\
     A##ptr(A             *g): REFptr<A>(g)     { }\
     A##ptr(const A##ptr  &p): REFptr<A>(p.p_)  { }\
     A##ptr(const A##subc &p): REFptr<A>(p.A##cast()) { } \
                                                   \
    virtual A *A##cast() const { return p_; } \
}

#endif // REF_H_HAS_BEEN_INCLUDED

---