ref.h

Go to the documentation of this file.

//
// Copyright (c) 2000-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Thu Oct 26 17:50:59 2000
// commit: $Id: ref.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/nub/ref.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX 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.
//
// GroovX 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.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_NUB_REF_H_UTC20050626084019_DEFINED
#define GROOVX_NUB_REF_H_UTC20050626084019_DEFINED

#include "nub/handle.h"
#include "nub/object.h"
#include "nub/weak_handle.h"

#include "rutz/fileposition.h" // for SRC_POS macro
#include "rutz/stderror.h"     // for rutz::throw_bad_cast()
#include "rutz/traits.h"

#include <typeinfo>

namespace nub
{
  template <class T> class ref;
  template <class T> class soft_ref;
  template <class T> class floating_ref;

  ref_vis get_default_ref_vis();

  void set_default_ref_vis(ref_vis vis);

  namespace detail
  {
    bool is_valid_uid(nub::uid id) throw();
    nub::object* get_checked_item(nub::uid id);

    void insert_item(nub::object* obj, ref_vis vis);

    template <class T>
    inline T* get_casted_item(nub::uid id)
    {
      nub::object* obj = get_checked_item(id);
      T* t = dynamic_cast<T*>(obj);
      if (t == 0)
        rutz::throw_bad_cast(typeid(T), typeid(nub::object), SRC_POS);
      return t;
    }

    template <>
    inline nub::object* get_casted_item<nub::object>(nub::uid id)
    { return get_checked_item(id); }

    template <class T>
    struct default_unref_policy
    {
      static void unref(T* t) throw() { t->decr_ref_count(); }
    };

    template <class T>
    struct no_delete_unref_policy
    {
      static void unref(T* t) throw() { t->decr_ref_count_no_delete(); }
    };

  } // end namespace nub::detail

} // end namespace nub

namespace rutz
{
  template <class T>
  struct type_traits<nub::ref<T> >
  {
    typedef T pointee_t;
  };

  template <class T>
  struct type_traits<nub::soft_ref<T> >
  {
    typedef T pointee_t;
  };
}







template <class T>
class nub::ref
{
private:

  typedef nub::detail::handle<T, nub::detail::default_unref_policy<T> >
  handle;

  handle m_handle;

public:
  // Default destructor, copy constructor, operator=() are fine

  explicit ref(nub::uid i)
    : m_handle(detail::get_casted_item<T>(i)) {}

  explicit ref(T* ptr, ref_vis vis = DEFAULT) :
    m_handle(ptr)
  {
    detail::insert_item(ptr, vis);
  }

  template <class U>
  ref(const ref<U>& other) : m_handle(other.get()) {}

  // Will raise an exception if the soft_ref is invalid
  template <class U>
  ref(const soft_ref<U>& other);


  void reset(T* p) { *this = ref(p); }

  T* operator->() const throw() { return get(); }
  T& operator*()  const throw() { return *(get()); }

  T* get()        const throw() { return m_handle.get(); }

  bool operator==(const ref& other) const throw()
  { return m_handle == other.m_handle; }

  bool operator!=(const ref& other) const throw()
  { return !(operator==(other)); }

  nub::uid id() const throw()
  { return get()->id(); }


  bool operator<(const ref& other) const throw()
  { return get() < other.get(); }
};

template <class To, class Fr>
nub::ref<To> dyn_cast(nub::ref<Fr> p)
{
  Fr* f = p.get();
  To* t = dynamic_cast<To*>(f);
  if (t == 0)
    rutz::throw_bad_cast(typeid(To), typeid(Fr), SRC_POS);
  return nub::ref<To>(t);
}

template <class To, class Fr>
void dyn_cast_to_from(nub::ref<To>& dest, nub::ref<Fr> p)
{
  dest = dyn_cast<To, Fr>(p);
}

// Compatibility interface with alternate function-naming:

template <class To, class Fr>
nub::ref<To> dynCast(nub::ref<Fr> p)
{ return dyn_cast<To, Fr>(p); }

template <class To, class Fr>
void dynCastToFrom(nub::ref<To>& dest, nub::ref<Fr> p)
{ dyn_cast_to_from<To, Fr>(dest, p); }





template <class T>
class nub::soft_ref
{
private:
  mutable detail::weak_handle<T> m_handle;

public:
  soft_ref() : m_handle(0, STRONG) {}

  explicit soft_ref(nub::uid i, ref_type tp = STRONG)
    :
    m_handle(detail::is_valid_uid(i) ?
             detail::get_casted_item<T>(i) : 0,
             tp)
  {}

  explicit soft_ref(T* master,
                    ref_type tp = STRONG, ref_vis vis = DEFAULT)
    :
    m_handle(master,tp)
  {
    if (m_handle.is_valid())
      {
        detail::insert_item(m_handle.get(), vis);
      }
  }

  template <class U>
  soft_ref(const soft_ref<U>& other) :
    m_handle(other.is_valid() ? other.get() : 0, STRONG) {}

  template <class U>
  soft_ref(const ref<U>& other) : m_handle(other.get(), STRONG) {}

  // Default destructor, copy constructor, operator=() are fine


  void reset(T* p = 0) { *this = soft_ref(p); }

  T* get()         const { return m_handle.get(); }

  T* operator->()  const { return m_handle.get(); }
  T& operator*()   const { return *(m_handle.get()); }

  T* get_weak() const throw() { return m_handle.get_weak(); }

  ref_type get_ref_type() const throw() { return m_handle.get_ref_type(); }

  bool is_valid()   const throw() { return m_handle.is_valid(); }
  bool is_invalid() const throw() { return !(is_valid()); }

  bool operator==(const soft_ref& other) const throw()
  { return get_weak() == other.get_weak(); }

  bool operator!=(const soft_ref& other) const throw()
  { return get_weak() != other.get_weak(); }

  bool operator<(const soft_ref& other) const throw()
  { return get_weak() < other.get_weak(); }

  nub::uid id() const throw()
  { return m_handle.is_valid() ? m_handle.get()->id() : 0; }

  // Compatibility interface with alternate function-naming:

  T*   getWeak()   const throw() { return this->get_weak(); }
  bool isValid()   const throw() { return this->is_valid(); }
  bool isInvalid() const throw() { return this->is_invalid(); }
};



template <class To, class Fr>
inline nub::soft_ref<To> dyn_cast(nub::soft_ref<Fr> p)
{
  if (p.is_valid())
    {
      Fr* f = p.get();
      To* t = dynamic_cast<To*>(f);
      if (t == 0)
        rutz::throw_bad_cast(typeid(To), typeid(Fr), SRC_POS);
      return nub::soft_ref<To>(t);
    }
  return nub::soft_ref<To>(p.id());
}

template <class To, class Fr>
inline void dyn_cast_to_from(nub::soft_ref<To>& dest,
                             nub::soft_ref<Fr> p)
{
  dest = dyn_cast<To, Fr>(p);
}


template <class To, class Fr>
inline nub::soft_ref<To> dyn_cast_weak(nub::soft_ref<Fr> p)
{
  if (p.is_valid())
    {
      Fr* f = p.get();
      To* t = dynamic_cast<To*>(f);
      if (t == 0)
        return nub::soft_ref<To>(); // return a null soft_ref
      return nub::soft_ref<To>(t);
    }
  return nub::soft_ref<To>(p.id());
}

template <class To, class Fr>
inline void dyn_cast_weak_to_from(nub::soft_ref<To>& dest,
                                  nub::soft_ref<Fr> p)
{
  dest = dyn_cast<To, Fr>(p);
}


template <class To, class Fr>
inline nub::soft_ref<To> dyn_cast_weak(nub::ref<Fr> p)
{
  Fr* f = p.get();
  To* t = dynamic_cast<To*>(f);
  if (t == 0)
    return nub::soft_ref<To>(); // return a null soft_ref
  return nub::soft_ref<To>(t);
}

template <class To, class Fr>
inline void dyn_cast_weak_to_from(nub::soft_ref<To>& dest,
                                  nub::ref<Fr> p)
{
  dest = dyn_cast<To, Fr>(p);
}


// Compatibility interface with alternate function-naming:

template <class To, class Fr>
inline nub::soft_ref<To> dynCast(nub::soft_ref<Fr> p)
{ return dyn_cast<To, Fr>(p); }


template <class To, class Fr>
inline void dynCastToFrom(nub::soft_ref<To>& dest,
                          nub::soft_ref<Fr> p)
{ dyn_cast_to_from<To, Fr>(dest, p); }


template <class To, class Fr>
inline nub::soft_ref<To> dynCastWeak(nub::soft_ref<Fr> p)
{ return dyn_cast_weak<To, Fr>(p); }


template <class To, class Fr>
inline void dynCastWeakToFrom(nub::soft_ref<To>& dest,
                              nub::soft_ref<Fr> p)
{ dyn_cast_weak_to_from<To, Fr>(dest, p); }


template <class To, class Fr>
inline nub::soft_ref<To> dynCastWeak(nub::ref<Fr> p)
{ return dyn_cast_weak<To, Fr>(p); }


template <class To, class Fr>
inline void dynCastWeakToFrom(nub::soft_ref<To>& dest,
                              nub::ref<Fr> p)
{ dyn_cast_weak_to_from<To, Fr>(dest, p); }





template <class T>
class nub::floating_ref
{
private:

  typedef nub::detail::handle<T, nub::detail::no_delete_unref_policy<T> >
  handle;

  handle m_handle;

  floating_ref(const floating_ref&);
  floating_ref& operator=(const floating_ref&);

public:
  // Default dtor is fine

  explicit floating_ref(T* ptr) : m_handle(ptr) {}

  T* operator->() const throw() { return get(); }
  T& operator*()  const throw() { return *(get()); }

  T* get()        const throw() { return m_handle.get(); }
};




//
// inline member definitions
//

template <class T>
template <class U>
inline nub::ref<T>::ref(const soft_ref<U>& other) :
  m_handle(other.get())
{}

static const char __attribute__((used)) vcid_groovx_nub_ref_h_utc20050626084019[] = "$Id: ref.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_NUB_REF_H_UTC20050626084019_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:39 2008 by Doxygen version 1.5.5.