gc_ptr.hh

//********************************************************************
//*** mm/gc_ptr.hh
//*** Copyright (c) 2002-2004 by Markus Winand <mws@fatalmind.com>
//*** $Id: gc_ptr.hh,v 1.26 2005/04/10 12:05:50 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

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() {};

        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;};

    private:
        int d_cnt;
        lock_t _lk;
};

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;
};

template<class T, class TM = fatalmind::DefaultThreadedModel>
class gc_ptr {
        typedef usg_cnt_t<TM> usg_cnt;
    public:
        explicit gc_ptr(T* p=0): d_ptr(p), d_usg(p != 0 ? new usg_cnt(): 0) {};
        //explicit gc_ptr(T* p=0): d_ptr(p), d_usg(new usg_cnt()) {};
            // need default constructor to work with STL

        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 = d_ptr != 0? new usg_cnt() : 0;
            }   
        }

        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) {
                delete d_usg;
                delete d_ptr;
            }
        }
};

#endif

---