vee_reference_object.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_REFERENCE_OBJECT_H
#define VEE_REFERENCE_OBJECT_H

template <typename T>
class VEE_ReferenceObj
{
public:
  VEE_ReferenceObj() : m_count(1) {}

  T m_object;
  unsigned m_count;
};

template <typename T>
class VEE_ReferenceObject
{
public:
  VEE_ReferenceObject() : m_holder(0) {}
  VEE_ReferenceObject(const T &obj) 
    : m_holder(new VEE_ReferenceObj<T>) { m_holder->m_object = obj; }
  
  VEE_ReferenceObject(const VEE_ReferenceObject &that)
  {
    m_holder = ((VEE_ReferenceObject *) & that)->m_holder; 
    if(m_holder)
      m_holder->m_count++;
  }
  
  ~VEE_ReferenceObject() { breakLink(); }

  T & ref() { check(); return m_holder->m_object; }
  const T & ref() const { check(); return m_holder->m_object; }

  T & operator *() { check(); return m_holder->m_object; }
  const T & operator *() const { check(); return m_holder->m_object; }

  void deepCopy(const VEE_ReferenceObject &that)
  { 
    if(!m_holder)
      m_holder = new VEE_ReferenceObj<T>;
    else if(m_holder->count > 1) {
      --m_holder->m_count;
      m_holder = new VEE_ReferenceObj<T>;
    }    
    m_holder->m_object = that.m_holder->m_object;
  }


  VEE_ReferenceObject & operator = (const VEE_ReferenceObject &that)
  { 
    that.check();
    if(m_holder == that.m_holder) return *this;

    breakLink(); 
    m_holder = ((VEE_ReferenceObject *) & that)->m_holder; 
    m_holder->m_count++;

    return *this;
  }

protected:

  void breakLink()
  { 
    if(!m_holder) return; 
    if(! --m_holder->m_count) 
      delete m_holder; 
    m_holder = 0;
  }

  void check() const
  { 
    if(!m_holder)
      ((VEE_ReferenceObject *) this)->m_holder = new VEE_ReferenceObj<T>; 
  }
  
  VEE_ReferenceObj<T> *m_holder;
};


template <typename T>
class VEE_ReferencePtr
{
public:
  VEE_ReferencePtr(T * obj = 0) : m_object(obj), m_count(1) {}
  ~VEE_ReferencePtr() { delete m_object; }
  
  T *m_object;
  unsigned m_count;
};

template <typename T>
class VEE_RefPtr
{
public:
  VEE_RefPtr() : m_holder(0) {}
  VEE_RefPtr(T *obj) 
    : m_holder(obj ? new VEE_ReferencePtr<T>(obj) : 0) { }
  
  VEE_RefPtr(const VEE_RefPtr &that)
  {
    m_holder = ((VEE_RefPtr *) & that)->m_holder; 
    if(m_holder) m_holder->m_count++;
  }
  
  ~VEE_RefPtr() { breakLink(); }

  T * ptr() { return m_holder ? m_holder->m_object : 0; }
  const T * ptr() const { return m_holder ? m_holder->m_object : 0; }

  T * operator *() { return m_holder ? m_holder->m_object : 0; }
  const T & operator *() const { return m_holder ? m_holder->m_object : 0; }

  VEE_RefPtr &link(T * obj) { return ((*this) = obj); }
  void clear() { breakLink(); }

  VEE_RefPtr & operator = (const VEE_RefPtr &that)
  { 
    if(m_holder == that.m_holder) return *this;

    breakLink(); 
    m_holder = ((VEE_RefPtr *) & that)->m_holder; 
    m_holder->m_count++;

    return *this;
  }

  VEE_RefPtr & operator = (T *obj)
  { 
    if(m_holder)
      if(obj == m_holder->m_object)
  return * this;

    breakLink(); 
    if(obj) 
      m_holder = new VEE_ReferencePtr<T>(obj); 
    return * this;
  }

  void breakLink()
  { 
    if(!m_holder) return; 
    if(! --m_holder->m_count) 
      delete m_holder; 
    m_holder = 0;
  }

  bool operator == (const VEE_RefPtr &that) const
  { return ptr() == that.ptr(); }

protected:

  
  VEE_ReferencePtr<T> *m_holder;
};

template <typename T>
class VEE_SafePtr
{
public:
  VEE_SafePtr(T * ptr = 0) : m_ptr(ptr) {}
  ~VEE_SafePtr() { delete m_ptr; }
  
  VEE_SafePtr & operator = (T *ptr) {delete m_ptr; m_ptr = ptr; return *this;}

  T * ptr() { return m_ptr; }

protected:
  T * m_ptr;

private:
  VEE_SafePtr & operator = (const VEE_SafePtr &) { return *this; }
};

#endif

---