gc_ptr.hh

//********************************************************************
//*** mm/gc_ptr.hh
//*** Copyright (c) 2002-2004 by Markus Winand <mws@fatalmind.com>
//*** $Id: gc_ptr.hh,v 1.30 2009-05-04 13:20:43 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2 of 
the License, or (at your option) any later version.

ResourcePool is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef INCLUDED_GC_PTR_HH
#define INCLUDED_GC_PTR_HH

#ifndef INCLUDED_THREAD_LOCK_HH
#include "Thread/Lock.hh"
#endif

#ifndef INCLUDED_THREAD_SYNCHRONIZE_HH
#include "Thread/Synchronize.hh"
#endif

namespace fatalmind {

// fwd decl
template<class T, class TM> class gc_ptr;

// See Alexandrescu, Modern C++ Design, par 2.7

// TODO, seperated version's to also work with fwd declared classes
template<class T, class U>
class Conversion
{
        typedef char Small;
        class Big {char dummy[2]; };

        static Small Test(U&);
        static Big   Test(...);
        static T&    MakeT();
    public:
        enum {exists = sizeof(Test(MakeT())) == sizeof(Small) };
};

template<class TM>
class usg_cnt_t {
        typedef typename TM::FastLock lock_t;
        typedef fatalmind::Synchronize<lock_t> sync;
    public:
        inline usg_cnt_t(): d_cnt(1) {};
        inline ~usg_cnt_t() {};

    private:
        inline int inc() {sync s(_lk); return ++d_cnt;};
        inline int dec() {sync s(_lk); return --d_cnt;};
        inline void reset() {sync s(_lk); d_cnt = 1;};

        int d_cnt;
        lock_t _lk;

        // hidden stuff
        // cctor
        usg_cnt_t(const usg_cnt_t&);

        template<class T, class TM2>
        friend
        class gc_ptr;
};

template<class T, class TM>
class gc_ptr_ref {
    public:
        gc_ptr_ref(T* ptr, usg_cnt_t<TM>* usg) 
        : d_ptr(ptr)
        , d_usg(usg)
        {
        }
        
        typedef usg_cnt_t<TM> usg_cnt;
        T* d_ptr;
        usg_cnt* d_usg;
};

// when the pointed type derives from usg_cnt_t, it works better ;)
// TODO, in that case it would be even possible to optimize d_usg (the member, which is a pointer) away completley ;)
template<class T, class TM = fatalmind::DefaultThreadedModel>
class gc_ptr {
        typedef usg_cnt_t<TM> usg_cnt;
    public:
        // need default constructor to work with STL
        explicit gc_ptr(T* p=0)
        : d_ptr(p)
        , d_usg( newUsageCounter(p))
        {
        };

        void resetFromExisting(T* ptr) 
        {
            if (d_ptr != ptr) {
                dispose();
                d_ptr = ptr;
                d_usg = ptr;
                d_usg->inc();
            }   
        }

        inline gc_ptr(const gc_ptr<T, TM>&p) throw()
        :   d_ptr(p.get()), d_usg(p.d_usg) 
        {
            if (d_usg) {
                d_usg->inc();
            }
        }

        inline gc_ptr(const gc_ptr_ref<T, TM>&p) throw()
        :   d_ptr(p.d_ptr), d_usg(p.d_usg) 
        {
            if (d_usg) {
                d_usg->inc();
            }
        }

        ~gc_ptr() throw() {
            dispose();
        }
    
        inline gc_ptr<T, TM>& operator= (const gc_ptr<T, TM>& p) throw()
        {
            if (this != &p) {
                dispose();
                d_ptr = p.d_ptr;
                d_usg = p.d_usg;
                if (d_usg) {
                    d_usg->inc();
                }
            }
            return *this;
        }

        inline T& operator*() const throw()
        {
            return *d_ptr;
        }
        
        inline T* operator->() const throw()
        {
            return d_ptr;
        }

        inline T* get() const throw()
        {
            return d_ptr;
        }

        inline bool isNull() const throw()
        {
            return d_ptr == 0;
        }
    
        void reset(T* ptr= 0) throw()
        {
            if (d_ptr != ptr) {
                dispose();
                d_ptr = ptr;
                d_usg = newUsageCounter(ptr);
            }   
        }

        inline bool operator<(const gc_ptr<T>& a) const {
            return *d_ptr < *a.d_ptr;
        }

        template<class Y>
        operator gc_ptr_ref<Y, TM>() throw() {
            return gc_ptr_ref<Y, TM>(d_ptr, d_usg);
        }

    protected:
        T* d_ptr;
        usg_cnt* d_usg;

        inline void dispose() throw() {
            if (d_usg != 0 && d_usg->dec() == 0) {
                if (!Conversion<T, usg_cnt>::exists) {
                    delete d_usg;
                }
                delete d_ptr;
            }
        }

        // advanced magic, thx to Andrei ;)
        // if the object we point to derives from usg_cnt,
        // then we use that usg_cnt and don't allocate a seperate one
        // in that case, we even don't need to check for 0, 
        // because in case d_ptr is null, d_cnt should anyaywas also be null
        static inline usg_cnt* newUsageCounter(const T* p) {
            return ( (Conversion<T, usg_cnt>::exists ?  
                      (usg_cnt*)(p) 
                    : (p != 0 ? 
                          new usg_cnt()
                        : 0))
            ) ;
        }
};

} // namespace fatalmind

#endif

---