#ifndef Handle_HH
#define Handle_HH

#include <assert.h>



// 
//
// Christopher L. Bladon
//
// Smart pointer "Handle" class.  Implements reference counting 
// for zero-reference delete.
//
// Warnings:
//	1) If you assign or construct a Handle to reference a 
//	pointer make sure it can be grabbed and eventually deleted
//	by this Handle<T> class.
//
// Example:
//
//      Handle<String> string = new String ("test");
//      List< Handle<String> > list;
//
//      list.add (string);
//      string = new String ("another test");
//	if (string) ...
//	if (string != 0) ...
//



template <class T> class Representation {
protected:
    T	*_data;
    int _flushed;
    int	num_references;

public:
    Representation (T *d = 0) : _data (d), _flushed (0), num_references (1) {}
    virtual ~Representation () { delete _data; }

    void increment_references () { ++num_references; }
    void decrement_references () { --num_references; }
    int references () const { return num_references; }

    virtual T *data () const { return _data; }

    int is_flushed () const { return _flushed; }
    virtual void flush () {}
};



template <class T> class Handle {
private:
    Representation<T> *rep;

    void attach (const Handle<T> &to);
    void detach ();


protected:
    virtual Representation<T> * create_representation (T *to = 0) { 
	return new Representation<T> (to); 
    }


public:
    Handle ();
    Handle (const Handle<T> &to);
    Handle (T *to);
    ~Handle ();

    Handle<T> & operator = (T *to);
    Handle<T> & operator = (const Handle<T> &to);

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

    int operator == (const Handle<T> &that) const;
    int operator != (const Handle<T> &that) const;
    int operator == (const T *that) const;
    int operator != (const T *that) const;
    int operator == (int that) const;
    int operator != (int that) const;

    T * operator -> ();
    const T * operator -> () const;
    T & operator * ();
    const T & operator * () const;

    // Bad Mojo, looses all control over the pointer
    T * data () const;

    virtual void flush () { rep->flush(); }
};



//
// The following classes allow casts up to one or two base handles.  This
// scheme only allows for single and double base classes.  For the single
// base class case Use it like this:
// 
// 
//	class Base {};
//	class Derived : public Base {};
//	...
//	DHandle<Derived, Base> derived;
//	Handle<Base> base = derived;
//
// Note: the D2Handle can be used for mulitple inheritance or a single
// inheritance tree of two base classes to which to cast.
//

template <class D, class B> class DHandle : public Handle<D> {
public:
    DHandle () : Handle<D> () {}
    DHandle (D *to) : Handle<D> (to) {}
    DHandle (const Handle<D> &to) : Handle<D> (to) {}

    operator const Handle<B> () const {
	return * (Handle<B> *) this;
    }
};

template <class D, class B1, class B2> class D2Handle : public DHandle<D,B1> {
public:
    D2Handle () : DHandle<D, B1> () {}
    D2Handle (D *to) : DHandle<D, B1> (to) {}

    operator const Handle<B2> () const {
	return * (Handle<B2> *) this;
    }
};



#endif