CommonPtr.hh

//********************************************************************
//*** mm/CommonPtr.hh
//*** Copyright (c) 2002-2005 by Markus Winand <mws@fatalmind.com>
//*** $Id: CommonPtr.hh,v 1.3 2005-08-13 18:08:22 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 MM_COMMONPTR_HH
#define MM_COMMONPTR_HH

#include <memory>
#include <mm/gc_ptr.hh>

namespace fatalmind {

template<class T, class TM>
class CommonPtr {
    public:
        CommonPtr() 
        : gc_p()
        , auto_p()
        , p()
        {
        }

        CommonPtr(gc_ptr<T, TM> a) 
        : gc_p(a)
        , auto_p()
        , p(gc_p.get())
        {
        }

        CommonPtr(std::auto_ptr<T> a) 
        : gc_p()
        , auto_p(a)
        , p(auto_p.get())
        {
        }

        CommonPtr(CommonPtr<T, TM>& rho)
        : gc_p(rho.gc_p)
        , auto_p(rho.auto_p)
        , p(rho.p)
        {
        }

        CommonPtr<T, TM>& operator=(CommonPtr<T, TM>& rho) {
            if (this != &rho) {
                gc_p = rho.gc_p;
                auto_p = rho.auto_p;
                p = rho.p;
            }
            return *this;
        }

        inline T& operator*() const throw() {
            return *this;
        }

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

        void reset()
        {
            auto_p.reset();
            gc_p.reset();
            p = 0;
        }

        void reset(gc_ptr<T, TM> a)
        {
            auto_p.reset();
            gc_p = a;
            p = gc_p.get();
        }

        void reset(std::auto_ptr<T> a)
        {
            gc_p.reset();
            auto_p = a;
            p = auto_p.get();
        }

        void reset(CommonPtr<T, TM> a) {
            gc_p   = a.gc_p;
            auto_p = a.auto_p;
            p      = a.p;
        }

        T* get() {
            return p;
        }

    private:
        gc_ptr<T, TM> gc_p;
        std::auto_ptr<T> auto_p;

        T* p;
};

} // namespace fatalmind

#endif

---