_handle.h

Go to the documentation of this file.

/* === E T L =============================================================== */
/* ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __ETL__HANDLE_H
#define __ETL__HANDLE_H

/* === H E A D E R S ======================================================= */

#include <cassert>

/* === M A C R O S ========================================================= */

/* === T Y P E D E F S ===================================================== */

#define ETL_SELF_DELETING_SHARED_OBJECT

/* === C L A S S E S & S T R U C T S ======================================= */

#ifdef NDEBUG
#define assert_cast     static_cast
#else
#define assert_cast     dynamic_cast
#endif


_ETL_BEGIN_NAMESPACE

// Forward Declarations
template <class T> class handle;
template <class T> class loose_handle;
template <class T> class rhandle;


// ========================================================================
class shared_object
{
private:
    mutable int refcount;
#ifdef ETL_LOCK_REFCOUNTS
    mutable etl::mutex mtx;
#endif

protected:
    shared_object():refcount(0) { }

#ifdef ETL_SELF_DELETING_SHARED_OBJECT
    virtual ~shared_object() { }
#else
    ~shared_object() { }
#endif

public:
    virtual void ref()const
    {
#ifdef ETL_LOCK_REFCOUNTS
        etl::mutex::lock lock(mtx);
#endif
        assert(refcount>=0);
        refcount++;
    }

    virtual bool unref()const
    {
        bool ret = true;
        {
#ifdef ETL_LOCK_REFCOUNTS
            etl::mutex::lock lock(mtx);
#endif
            assert(refcount>0);

            refcount--;

            if(refcount==0) {
                ret = false;
#ifdef ETL_SELF_DELETING_SHARED_OBJECT
                refcount=-666;
#endif
            }
        }

#ifdef ETL_SELF_DELETING_SHARED_OBJECT
        if (!ret)
            delete this;
#endif
        return ret;
    }

    virtual bool unref_inactive()const
    {
        bool ret = true;
        {
#ifdef ETL_LOCK_REFCOUNTS
            etl::mutex::lock lock(mtx);
#endif
            assert(refcount>0);

            refcount--;

            if(refcount==0)
                ret = false;
        }

        return ret;
    }

    int count()const { return refcount; }

}; // END of class shared_object

// ========================================================================
class virtual_shared_object
{
protected:
    virtual_shared_object() { }
public:
    virtual ~virtual_shared_object()=0;
    virtual void ref()const=0;
    virtual bool unref()const=0;
    virtual bool unref_inactive()const=0;
    virtual int count()const=0;
}; // END of class virtual_shared_object

// ========================================================================
template <class T>
class handle
{
public:

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef int count_type;
    typedef int size_type;

protected:
#ifdef _DEBUG
public:
#endif
    value_type *obj;        

public:

    handle():obj(NULL) {}

    handle(pointer x):obj(x)
    {
        if(obj)
            obj->ref();
    }

    handle(const handle<value_type> &x):obj(x.get())
    {
        if(obj)
            obj->ref();
    }

    ~handle() { detach(); }


    /*
    template <class U> handle<value_type> &
    operator=(const handle<U> &x)
    {
        if(x.get()==obj)
            return *this;

        detach();

        obj=static_cast<value_type*>(x.get());
        if(obj)obj->ref();
        return *this;
    }
    */

    handle<value_type> &
    operator=(const handle<value_type> &x)
    {
        if(x.get()==obj)
            return *this;

        detach();

        obj=x.get();
        if(obj)obj->ref();
        return *this;
    }

    handle<value_type> &
    swap(handle<value_type> &x)
    {
        pointer ptr=x.obj;
        x.obj=obj;
        obj=ptr;
        return *this;
    }


    void
    detach()
    {
        pointer xobj(obj);
        obj=0;
#ifdef ETL_SELF_DELETING_SHARED_OBJECT
        if(xobj)
            xobj->unref();
#else
        if(xobj && !xobj->unref())
            delete xobj;
#endif
    }

    // This will be reintroduced with a new function
    //void release() { detach(); }

    void reset() { detach(); }

    bool empty()const { return obj==0; }


    void spawn() { operator=(handle(new T())); }

    handle<const value_type> constant()const { assert(obj); return *this; }

    count_type
    count()const
        { return obj?obj->count():0; }

    bool
    unique()const
        { assert(obj); return count()==1; }

    reference
    operator*()const
        { assert(obj); return *obj; }

    pointer
    operator->()const
        { assert(obj); return obj; }

    operator bool()const
        { return obj!=NULL; }

    operator handle<const value_type>()const
    { return handle<const value_type>(static_cast<const_pointer>(obj)); }

    template <class U> static handle<T> cast_static     (const handle<U> &x) { return handle<T>(static_cast     <T*>(x.get())); }
    template <class U> static handle<T> cast_dynamic    (const handle<U> &x) { return handle<T>(dynamic_cast    <T*>(x.get())); }
    template <class U> static handle<T> cast_const      (const handle<U> &x) { return handle<T>(const_cast      <T*>(x.get())); }
    template <class U> static handle<T> cast_reinterpret(const handle<U> &x) { return handle<T>(reinterpret_cast<T*>(x.get())); }

    template <class U> static handle<T> cast_static     (const loose_handle<U> &x);
    template <class U> static handle<T> cast_dynamic    (const loose_handle<U> &x);
    template <class U> static handle<T> cast_const      (const loose_handle<U> &x);
    template <class U> static handle<T> cast_reinterpret(const loose_handle<U> &x);

    template <class U> static handle<T> cast_static     (const rhandle<U> &x);
    template <class U> static handle<T> cast_dynamic    (const rhandle<U> &x);
    template <class U> static handle<T> cast_const      (const rhandle<U> &x);
    template <class U> static handle<T> cast_reinterpret(const rhandle<U> &x);

    template <class U> static handle<T> cast_static     (U* x);
    template <class U> static handle<T> cast_dynamic    (U* x);
    template <class U> static handle<T> cast_const      (U* x);
    template <class U> static handle<T> cast_reinterpret(U* x);

    pointer get()const { return obj; }

    bool
    operator!()const
        { return !obj; }

    template <class U>
    operator handle<U>()const
    { return handle<U>(static_cast<U*>(obj)); }
}; // END of template class handle

// ========================================================================
class rshared_object : public shared_object
{
private:
    mutable int rrefcount;

public:
    void *front_;
    void *back_;

protected:
    rshared_object():rrefcount(0),front_(0),back_(0) { }

public:
    virtual void rref()const
        { rrefcount++; }

    virtual void runref()const
    {
        assert(rrefcount>0);
        rrefcount--;
    }

    int rcount()const
        { return rrefcount; }
}; // END of class rshared_object

// ========================================================================
template <class T>
class rhandle : public handle<T>
{
    friend class rshared_object;
public:

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef int count_type;
    typedef int size_type;


    using handle<value_type>::count;
    using handle<value_type>::unique;
    using handle<value_type>::operator bool;
    using handle<value_type>::get;
    using handle<value_type>::operator*;
    using handle<value_type>::operator->;

    /*
    operator const handle<value_type>&()const
    { return *this; }
    */

private:
    using handle<value_type>::obj;

    rhandle<value_type> *prev_;
    rhandle<value_type> *next_;

    void add_to_rlist()
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing

        assert(obj);
        obj->rref();

        // If this is the first reversible handle
        if(!obj->front_)
        {
            obj->front_=obj->back_=this;
            prev_=next_=0;
            return;
        }

        prev_=reinterpret_cast<rhandle<value_type>*>(obj->back_);
        next_=0;
        prev_->next_=this;
        obj->back_=this;
    }

    void del_from_rlist()
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        assert(obj);
        obj->runref();

        // If this is the last reversible handle
        if(obj->front_==obj->back_)
        {
            obj->front_=obj->back_=0;
            prev_=next_=0;
            return;
        }

        if(!prev_)
            obj->front_=(void*)next_;
        else
            prev_->next_=next_;

        if(!next_)
            obj->back_=(void*)prev_;
        else
            next_->prev_=prev_;
    }

public:

    rhandle() {}

    rhandle(pointer x):handle<T>(x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(obj)add_to_rlist();
    }

    rhandle(const handle<value_type> &x):handle<T>(x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(obj)add_to_rlist();
    }

    rhandle(const rhandle<value_type> &x):handle<T>(x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(obj)add_to_rlist();
    }

    ~rhandle() { detach(); }


    /*
    template <class U> const handle<value_type> &
    operator=(const handle<U> &x)
    {
        if(x.get()==obj)
            return *this;

        detach();

        obj=static_cast<value_type*>(x.get());
        if(obj)
        {
            obj->ref();
            add_to_rlist();
        }
        return *this;
    }
    */

    rhandle<value_type> &
    operator=(const rhandle<value_type> &x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(x.get()==obj)
            return *this;

        detach();

        obj=x.get();
        if(obj)
        {
            obj->ref();
            add_to_rlist();
        }
        return *this;
    }

    rhandle<value_type>&
    operator=(const handle<value_type> &x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(x.get()==obj)
            return *this;

        detach();

        obj=x.get();
        if(obj)
        {
            obj->ref();
            add_to_rlist();
        }
        return *this;
    }

    rhandle<value_type>&
    operator=(value_type* x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(x==obj)
            return *this;

        detach();

        obj=x;
        if(obj)
        {
            obj->ref();
            add_to_rlist();
        }
        return *this;
    }


    void
    detach()
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        if(obj)del_from_rlist();
        handle<value_type>::detach();
        obj=0;
    }

    // This will be reintroduced with a new function
    //void release() { detach(); }

    void reset() { detach(); }


    void spawn() { operator=(handle<value_type>(new T())); }

    count_type
    rcount()const
    {
//      value_type*const& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        return obj?obj->rcount():0;
    }

    bool
    runique()const
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        assert(obj); return obj->front_==obj->back_;
    }

    int replace(const handle<value_type> &x)
    {
//      value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
        assert(obj);
        assert(x.get()!=obj);

        if(x.get()==obj)
            return 0;

        rhandle<value_type> *iter;
        rhandle<value_type> *next;

        iter=reinterpret_cast<rhandle<value_type>*>(obj->front_);

        assert(iter);

        next=iter->next_;

        int i=0;
        #ifndef NDEBUG
        pointer obj_=obj;
        #endif

        for(;iter;iter=next,next=iter?iter->next_:0,i++)
        {
            assert(iter->get()==obj_);
            (*iter)=x;
        }

        assert(obj==x.get());

        return i;
    }


    handle<value_type> &
    swap(handle<value_type> &x);
    /*
    {
        assert(0);
        pointer ptr=x.obj;
        x.obj=obj;
        obj=ptr;
        return *this;
    }
    */
}; // END of template class rhandle


// ========================================================================
template <class T>
class loose_handle
{
public:

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef int count_type;
    typedef int size_type;

protected:
#ifdef _DEBUG
public:
#endif
    value_type *obj;        

public:

    loose_handle():obj(0) {}

    loose_handle(pointer x):obj(x) { }

    loose_handle(const loose_handle<value_type> &x):obj(x.get()) { }

    loose_handle(const handle<value_type> &x):obj(x.get()) { }

    template <class U> const loose_handle<value_type> &
    operator=(const handle<U> &x)
    {
        if(x.get()==obj)
            return *this;

        obj=static_cast<value_type*>(x.get());
        return *this;
    }

    template <class U> const loose_handle<value_type> &
    operator=(const loose_handle<U> &x)
    {
        if(x.get()==obj)
            return *this;

        obj=static_cast<value_type*>(x.get());
        return *this;
    }

    const loose_handle<value_type> &
    operator=(const loose_handle<value_type> &x)
    {
        if(x.get()==obj)
            return *this;

        obj=x.get();
        return *this;
    }

    loose_handle<value_type> &
    swap(loose_handle<value_type> &x)
    {
        pointer ptr=x.obj;
        x.obj=obj;
        obj=ptr;
        return *this;
    }

    void detach() { obj=0;  }

    // This will be reintroduced with a new function
    //void release() { detach(); }

    void reset() { detach(); }

    bool empty()const { return obj==0; }

    loose_handle<const value_type> constant()const { return *this; }

    count_type
    count()const
        { return obj?obj->count():0; }

    reference
    operator*()const
        { assert(obj); return *obj; }

    pointer
    operator->()const
        { assert(obj); return obj; }

    //template <class U>
    //operator loose_handle<U>()const
    //{ return loose_handle<U>(static_cast<U*>(obj)); }

    operator loose_handle<const value_type>()const
    { return loose_handle<const value_type>(static_cast<const_pointer>(obj)); }

    operator handle<value_type>()const
    { return handle<value_type>(obj); }

    operator rhandle<value_type>()const
    { return rhandle<value_type>(obj); }

    pointer get()const { return obj; }

    operator bool()const
        { return obj!=0; }

    bool
    operator!()const
        { return !obj; }

    void ref() { if(obj)obj->ref(); }

    bool unref() { if(obj && !obj->unref()){ obj=0; return false; } return true; }
}; // END of template class loose_handle

// cast loose_handle<> -> handle<>
template <class T> template <class U> handle<T> handle<T>::cast_static     (const loose_handle<U>& x) { return handle<T>(static_cast     <T*>(x.get())); }
template <class T> template <class U> handle<T> handle<T>::cast_dynamic    (const loose_handle<U>& x) { return handle<T>(dynamic_cast    <T*>(x.get())); }
template <class T> template <class U> handle<T> handle<T>::cast_const      (const loose_handle<U>& x) { return handle<T>(const_cast      <T*>(x.get())); }
template <class T> template <class U> handle<T> handle<T>::cast_reinterpret(const loose_handle<U>& x) { return handle<T>(reinterpret_cast<T*>(x.get())); }

// cast rhandle_handle<> -> handle<>
template <class T> template <class U> handle<T> handle<T>::cast_static     (const rhandle<U>&      x) { return handle<T>(static_cast     <T*>(x.get())); }
template <class T> template <class U> handle<T> handle<T>::cast_dynamic    (const rhandle<U>&      x) { return handle<T>(dynamic_cast    <T*>(x.get())); }
template <class T> template <class U> handle<T> handle<T>::cast_const      (const rhandle<U>&      x) { return handle<T>(const_cast      <T*>(x.get())); }
template <class T> template <class U> handle<T> handle<T>::cast_reinterpret(const rhandle<U>&      x) { return handle<T>(reinterpret_cast<T*>(x.get())); }

// cast U* -> handle<>
template <class T> template <class U> handle<T> handle<T>::cast_static     (U*                     x) { return handle<T>(static_cast     <T*>(x));       }
template <class T> template <class U> handle<T> handle<T>::cast_dynamic    (U*                     x) { return handle<T>(dynamic_cast    <T*>(x));       }
template <class T> template <class U> handle<T> handle<T>::cast_const      (U*                     x) { return handle<T>(const_cast      <T*>(x));       }
template <class T> template <class U> handle<T> handle<T>::cast_reinterpret(U*                     x) { return handle<T>(reinterpret_cast<T*>(x));       }

// operator== for handle<>, loose_handle<> and T*
template <class T,class U> bool operator==(const handle		 <T>& lhs,const handle		<U>& rhs) { return (lhs.get()==rhs.get()); }
template <class T,class U> bool operator==(const loose_handle<T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()==rhs.get()); }
template <class T,class U> bool operator==(const handle		 <T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()==rhs.get()); }
template <class T,class U> bool operator==(const loose_handle<T>& lhs,const handle		<U>& rhs) { return (lhs.get()==rhs.get()); }
template <class T>         bool operator==(const handle<T>&       lhs,const T*               rhs) { return (lhs.get()==rhs);       }
template <class T>         bool operator==(const loose_handle<T>& lhs,const T*               rhs) { return (lhs.get()==rhs);       }
template <class T>         bool operator==(const T*               lhs,const handle<T>&       rhs) { return (lhs      ==rhs.get()); }
template <class T>         bool operator==(const T*               lhs,const loose_handle<T>& rhs) { return (lhs      ==rhs.get()); }

// operator!= for handle<>, loose_handle<> and T*
template <class T,class U> bool operator!=(const handle		 <T>& lhs,const handle		<U>& rhs) { return (lhs.get()!=rhs.get()); }
template <class T,class U> bool operator!=(const loose_handle<T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()!=rhs.get()); }
template <class T,class U> bool operator!=(const handle		 <T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()!=rhs.get()); }
template <class T,class U> bool operator!=(const loose_handle<T>& lhs,const handle		<U>& rhs) { return (lhs.get()!=rhs.get()); }
template <class T>         bool operator!=(const handle<T>&       lhs,const T*               rhs) { return (lhs.get()!=rhs);       }
template <class T>         bool operator!=(const loose_handle<T>& lhs,const T*               rhs) { return (lhs.get()!=rhs);       }
template <class T>         bool operator!=(const T*               lhs,const handle<T>&       rhs) { return (lhs      !=rhs.get()); }
template <class T>         bool operator!=(const T*               lhs,const loose_handle<T>& rhs) { return (lhs      !=rhs.get()); }

// operator< for handle<>, loose_handle<> and T*
template <class T,class U> bool operator<(const handle<T>&        lhs,const handle<U>&       rhs) { return (lhs.get()<rhs.get());  }
template <class T,class U> bool operator<(const loose_handle<T>&  lhs,const loose_handle<U>& rhs) { return (lhs.get()<rhs.get());  }
template <class T,class U> bool operator<(const handle<T>&        lhs,const loose_handle<U>& rhs) { return (lhs.get()<rhs.get());  }
template <class T,class U> bool operator<(const loose_handle<T>&  lhs,const handle<U>&       rhs) { return (lhs.get()<rhs.get());  }
template <class T>         bool operator<(const handle<T>&        lhs,const T*               rhs) { return (lhs.get()<rhs);        }
template <class T>         bool operator<(const loose_handle<T>&  lhs,const T*               rhs) { return (lhs.get()<rhs);        }
template <class T>         bool operator<(const T*                lhs,const handle<T>&       rhs) { return (lhs      <rhs.get());  }
template <class T>         bool operator<(const T*                lhs,const loose_handle<T>& rhs) { return (lhs      <rhs.get());  }

_ETL_END_NAMESPACE

/* === E N D =============================================================== */

#endif