+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

auto_reference.h

Go to the documentation of this file.

// -*-c++-*-
//----------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file  auto_reference.h
 *
 * Auto reference similar to auto pointers
 *
 * <br>@b Designer(s):  Randy Sargent
 * <br>@b Author(s):    Randy Sargent
 * <br>@b Date:         March 13, 2004
 *
 * <b>Software License:</b><br>
 * <code> http://claraty.jpl.nasa.gov/license/open_src/  or 
 *        file: license/open_src.txt </code>
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology<br>
 * &copy; 2006, NASA Ames Research Center
 *
 * $Revision: 1.4 $
 */
//-----------------------------------------------------------------------------

#ifndef  AUTO_REF_H
#define  AUTO_REF_H

#include "claraty/share.h"

#include <iostream>
#include <assert.h>

// ACE includes
//#include "ace/Synch.h"
#include "claraty/semaphore.h"

namespace claraty {

template <class T> class Auto_Ref;
template <class T> class const_Auto_Ref;

// Clay had to pull this out of the private section of Auto_Ref because of
// compiler confusion resulting from mixing Auto_Ref's of different types.
// So instead of keeping it as a private Auto_Ref helper class, the thing is
// entirely private, but it keeps Auto_Ref as a friend.
template<class RT>
class ref_counter {
  int refcount;
  //mutable ACE_Recursive_Thread_Mutex lock;
  mutable Semaphore lock; 
  RT *_rep;

  explicit ref_counter(const ref_counter&);

  friend class Auto_Ref<RT>;
  friend class const_Auto_Ref<RT>;

  ref_counter(RT *&r) : refcount(1), lock(), _rep(r) { }
  ref_counter() : refcount(1), lock(), _rep(NULL) { }
  ~ref_counter() { }

  void inc() {
    lock.acquire();
    refcount++;
    lock.release();
  }

  int dec() {
    lock.acquire();
    if (--refcount == 0)
      delete _rep;
    int val = refcount;
    lock.release();
    return val;
  }

  // Calling this function probably won't do what you want, since
  // the refcount can be invalidated before it is returned
  int get_count() const {
    lock.acquire();
    int val = refcount;
    lock.release();
    return val;
  }

  void make_null_if_unique() {
    lock.acquire();
    if (refcount == 1) {
      delete _rep;
      _rep= NULL;
    }
    lock.release();
  }
};

template <class T>
class Auto_Ref {
  friend class const_Auto_Ref<T>;

  ref_counter<T> *_rc;
  
public:
  Auto_Ref() { _rc= new ref_counter<T>(); }
  explicit Auto_Ref(T *&ptr) { _rc = new ref_counter<T>(ptr); ptr = 0; }
  Auto_Ref(const Auto_Ref& rhs) {
    _rc = rhs._rc;
    _rc->inc();
  }
  ~Auto_Ref() {
    if (_rc->dec() == 0) delete _rc;
  }

  // Why does this function have such a long name? To remind you that you
  // really shouldn't be calling it, ever. It should only be used by the
  // internal operator== function.
  const void *get_const_representation_pointer() const { return _rc; }

  Auto_Ref& operator=(const Auto_Ref& rhs) {
    if (_rc != rhs._rc) {
      if (_rc->dec() == 0) delete _rc;
      _rc = rhs._rc;
      _rc->inc();
    }
    return *this;
  }

  template <class R>
  bool operator==(const Auto_Ref<R>& rhs) const {
    return static_cast<void*>(_rc) == rhs.get_const_representation_pointer();
  }

  template <class R>
  bool operator!=(const Auto_Ref<R>& rhs) const {
    return !operator==(rhs);
  }

  // evil casting function, which casts what we're reffing to a subclass
  // thereof. This would throw bad cast if the dynamic cast fails, but for now
  // it simply causes the program to abort.
  template <class S>
  void cast_to(Auto_Ref<S>& rhs) {
    if (dynamic_cast<S*>(_rc->_rep) == NULL) {
      std::cerr << "Illegal attempt to cast an Auto_Ref<T> to an Auto_Ref<U> where "
        "U is not castable from T (or from a NULL Auto_Ref)" << std::endl;
      S& dummy = dynamic_cast<S&>(*_rc->_rep); // will throw bad_cast
    }
    ref_counter<S> *rc_subclass = reinterpret_cast<ref_counter<S>*>(_rc);
    rhs.reset_rc(rc_subclass);
  }

  // casting to something of the same type is esy
  void cast_to(Auto_Ref<T>& rhs) {
    rhs = *this;
  }

  // This can only be called by other Auto_Ref's since they're the only ones
  // who have access to the ref_counter sibling type. The function is public
  // because Auto_Ref's of other types are not our friends.
  void reset_rc(ref_counter<T> *new_rc) {
    if (_rc->dec() == 0) delete _rc;
    _rc = new_rc;
    _rc->inc();
  }

  void reset(T *&ptr) {
    if (_rc->dec() == 0) delete _rc;
    _rc = new ref_counter<T>(ptr);
    ptr = 0;
  }

  T *get() const {
    return _rc->_rep;
  }

  void get_ptr(T *&p) const {
    p = _rc->_rep;
  }

  template <class U>
  void get_ptr(U *&p) {
    p = dynamic_cast<U*>(_rc->_rep);
  }

  // Frees object and changes pointer to NULL if you have
  // the only copy
  void make_null_if_unique() {
    _rc->make_null_if_unique();
  }
  
  void make_unique() {
    _rc->lock.acquire();
    if (_rc->get_count() <= 1) {
      assert(_rc->get_count() == 1); // should never get to zero while we care
      _rc->lock.release();
    } else {
      T *copy = _rc->_rep->clone();
      ref_counter<T> *rc = new ref_counter<T>(copy);
      _rc->dec();
      assert(_rc->get_count() > 0); // since we know it was greater than 1
      _rc->lock.release();
      _rc = rc;
    }
  }
  
  const T& operator*() const {
    return *_rc->_rep;
  }

  const T *operator->() const {
    return _rc->_rep;
  }

  T& operator*() {
    return *_rc->_rep;
  }

  T *operator->() {
    return _rc->_rep;
  }

  operator bool() const {
    return !!_rc->_rep;
  }
  bool operator!() const {
    return !_rc->_rep;
  }
};

template <class T>
class const_Auto_Ref {
  ref_counter<T> *_rc;
public:
  const_Auto_Ref() { _rc = new ref_counter<T>(); }
  const_Auto_Ref(const const_Auto_Ref& rhs) {
    _rc = rhs._rc;
    _rc->inc();
  }
  const_Auto_Ref(const Auto_Ref<T>& rhs) {
    _rc = rhs._rc;
    _rc->inc();
  }
  ~const_Auto_Ref() {
    if (_rc->dec() == 0) delete _rc;
  }

  // Why does this function have such a long name? To remind you that you
  // really shouldn't be calling it, ever. It should only be used by the
  // internal operator== function.
  const void *get_const_representation_pointer() const { return _rc; }

  const_Auto_Ref& operator=(const const_Auto_Ref& rhs) {
    if (_rc != rhs._rc) {
      if (_rc->dec() == 0) delete _rc;
      _rc = rhs._rc;
      _rc->inc();
    }
    return *this;
  }

  // evil casting function, which casts what we're reffing to a subclass
  // thereof. This would throw bad cast if the dynamic cast fails, but for now
  // it simply causes the program to abort.
  template <class S>
  void cast_to(const_Auto_Ref<S>& rhs) {
    if (dynamic_cast<S*>(_rc->_rep) == NULL) {
      std::cerr << "Illegal attempt to cast an Auto_Ref<T> to an Auto_Ref<U> where "
        "U is not castable from T (or from a NULL Auto_Ref)" << std::endl;
      S& dummy = dynamic_cast<S&>(*_rc->_rep); // will throw bad_cast
    }
    ref_counter<S> *rc_subclass = reinterpret_cast<ref_counter<S>*>(_rc);
    rhs.reset_rc(rc_subclass);
  }

  // casting to something of the same type is esy
  void cast_to(const_Auto_Ref<T>& rhs) {
    rhs = *this;
  }

  // This can only be called by other Auto_Ref's since they're the only ones
  // who have access to the ref_counter sibling type. The function is public
  // because Auto_Ref's of other types are not our friends.
  void reset_rc(ref_counter<T> *new_rc) {
    if (_rc->dec() == 0) delete _rc;
    _rc = new_rc;
    _rc->inc();
  }

  template <class R>
  bool operator==(const const_Auto_Ref<R>& rhs) const {
    return static_cast<void*>(_rc) == rhs.get_const_representation_pointer();
  }

  template <class R>
  bool operator!=(const const_Auto_Ref<R>& rhs) const {
    return !operator==(rhs);
  }
  const T& operator*() const {
    return *_rc->_rep;
  }

  const T *operator->() const {
    return _rc->_rep;
  }

  operator bool() const {
    return !!_rc->_rep;
  }
  bool operator!() const {
    return !_rc->_rep;
  }
};

} // namespace claraty

#endif // AUTO_REF_H

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635