#include "Handle.hh"


template <class T> 
Handle<T>::Handle (const Handle<T> &to) {
    attach (to);
}



template <class T> 
Handle<T>::Handle (T *to)
    : rep (0)
{
    *this = to;		// invoke op =
}



template <class T> 
Handle<T>::Handle () {
    rep = create_representation ();
}



template <class T> 
Handle<T>::~Handle () {
    detach ();
}


template <class T> 
Handle<T> & Handle<T>::operator = (const Handle<T> &to) {
    detach ();
    attach (to);

    return *this;
}



template <class T> 
Handle<T> & Handle<T>::operator = (T *to) {
    detach ();
    rep = create_representation (to);

    return *this;
}




template <class T> 
T * Handle<T>::data () const {
    assert (rep != 0);
    return rep->data();
}



template <class T> 
T * Handle<T>::operator -> () {
    assert (rep != 0);
    return rep->data();
}



template <class T> 
const T * Handle<T>::operator -> () const {
    assert (rep != 0);
    return rep->data();
}



template <class T> 
T & Handle<T>::operator * () {
    assert (rep != 0);
    return *rep->data();
}



template <class T> 
const T & Handle<T>::operator * () const {
    assert (rep != 0);
    return *rep->data();
}



template <class T> 
void Handle<T>::attach (const Handle<T> &to) {
    rep = to.rep;
    rep->increment_references ();
}



template <class T> 
void Handle<T>::detach () {
    if (rep) {
	rep->decrement_references ();
	if (rep->references() == 0) delete rep;
    }
}



template <class T> 
int Handle<T>::operator == (const Handle<T> &that) const {
    assert (this->rep != 0);
    assert (that.rep != 0);
    return this->rep->data() == that.rep->data();
}



template <class T> 
int Handle<T>::operator != (const Handle<T> &that) const {
    assert (this->rep != 0);
    assert (that.rep != 0);
    return this->rep->data() != that.rep->data();
}



template <class T> 
int Handle<T>::operator == (const T *that_ptr) const {
    assert (this->rep != 0);
    return this->rep->data() == that_ptr;
}



template <class T> 
int Handle<T>::operator != (const T *that_ptr) const {
    assert (this->rep != 0);
    return this->rep->data() != that_ptr;
}


template <class T> 
int Handle<T>::operator == (int that) const {
    assert (this->rep != 0);
    return this->rep->data() == (void *) that;
}



template <class T> 
int Handle<T>::operator != (int that) const {
    assert (this->rep != 0);
    return this->rep->data() != (void *) that;
}