smart_ptr.h

Go to the documentation of this file.

/*  smart_ptr.h - Smart pointer which adds a reference count to
    legacy objects.  Comes in thread safe and single threaded
    versions.

    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

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

    This library 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
    Library General Public License for more details.

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

#ifndef OW32_smart_ptr_h
#define OW32_smart_ptr_h

namespace OW32
{

class smart_ptr_single_thread_model
{
public:
    static LONG increment(LPLONG p) { return ++(*p); }
    static LONG decrement(LPLONG p) { return --(*p); } 
};

class smart_ptr_multi_thread_model
{
public:
    static LONG increment(LPLONG p) { return InterlockedIncrement(p); }
    static LONG decrement(LPLONG p) { return InterlockedDecrement(p); }
};

template <class T, class thread_model = smart_ptr_multi_thread_model>
class smart_ptr
{
    T* m_ptr;
    LONG* m_count;

public:
    smart_ptr() : m_ptr(0),m_count(0L) {}
    explicit smart_ptr(T* ptr) : m_ptr(ptr),m_count(new LONG(1L)) {}

    smart_ptr(const smart_ptr<T>& other) :
        m_ptr(other.m_ptr),
        m_count(other.m_count)
    {
        if (m_count) thread_model::increment(m_count);
    }

    smart_ptr& operator=(const smart_ptr& other)
    {
        if (this != &other)
        {
            release();
            m_ptr = other.m_ptr;
            m_count = other.m_count;
            if (m_count) thread_model::increment(m_count);
        }
        return *this;
    }

    ~smart_ptr() { release(); }

    void release() {
        if (m_count && thread_model::decrement(m_count)==0) {
            delete m_ptr;
            delete m_count;
        }
        m_ptr = 0;
        m_count = 0;
    }
    
    T* get() {
        return m_ptr;
    }

    void reset(T* newptr) {
        release();
        m_ptr = T;
        m_count = new LONG(1L);
    }

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

} // namespace OW32

#endif // OW32_smart_ptr_h

---