---

IotrHandle.hh

#ifndef IOTRHANDLE
#define IOTRHANDLE

#include <assert.h>

template <class T>
class Handle {
public:
  Handle() : obj(0) {};

  Handle( const Handle<T>& handle )
  {
    this->obj = handle.ptr();
  };
#ifdef HAVE_MEMBER_TEMPLATES
  template <class S>
  Handle( const Handle<S>& handle )
  {
    this->obj = handle.ptr();
  }
#endif



  T& operator*() { return *obj; };
  const T& operator*() const { return *obj; };


  Handle<T>& operator=( const Handle<T>& handle)
  {
    T * newobj = handle.ptr();
    if( this->obj ) IotrRelease( &this->obj );

    this->obj = newobj;

    return *this;
  };
#ifdef HAVE_MEMBER_TEMPLATES
  template <class S>
  Handle<T>& operator=(const Handle<S>& handle)
  {
    S * ptrin = handle.ptr();
    if( this->obj ) IotrRelease( &this->obj );

    this->obj = ptrin;

    return *this;
  }
#endif

  ~Handle()
  {
    if( obj ) IotrRelease( &obj );
  }

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

  operator T*()
  {
    return obj;
  }
  static void bind( Handle<T>& handle, T ** obj )
  {
    handle.obj = *obj;
    *obj   = 0;
  }
  static void referTo( Handle<T>& handle, T * obj )
  {
    if( obj )    IotrAddRef( &obj );
    if( handle.obj ) IotrRelease( &handle.obj );

    handle.obj = obj;
  }
  T * ptr() const
  {
    if (obj) IotrAddRef( &obj );

    return obj;
  }

#ifdef HAVE_EXPLICIT
  explicit
#endif
        Handle( T * t ) : obj(t) {}
protected:
  T * obj;
};

template <class T>
inline void HandleNil( Handle<T>& handle )
{
  T * t = 0;
  Handle<T>::bind( handle, &t );
}

template <class T>
inline void HandleReferTo( Handle<T>& handle, T * obj )
{
  Handle<T>::referTo( handle, obj );
}


template <class T>
inline T * HandleAsPointer( Handle<T>& handle )
{
  return handle.ptr();
}

#endif

---