refcount.h

Go to the documentation of this file.

/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef OMGUI_REFCOUNT_H
#define OMGUI_REFCOUNT_H

#include <omgui/dllimpexp.h>
#include <functional>
#include <assert.h>

namespace omgui {

template<typename T> class Pointer
{
public:
    Pointer(T *p = 0, bool add_ref = true): m_p(p)
    {
        if( m_p != 0 && add_ref ) intrusive_ptr_add_ref(m_p);
    }

    Pointer(const Pointer &p): m_p(p.m_p)
    {
        if( m_p != 0 ) intrusive_ptr_add_ref(m_p);
    }

    template<typename U> Pointer(const Pointer<U> &p): m_p(p.get())
    {
        if( m_p != 0 ) intrusive_ptr_add_ref(m_p);
    }

    ~Pointer()
    {
        if( m_p != 0 ) intrusive_ptr_release(m_p);
    }

    T *operator-> () const
    {
        assert(m_p != 0);
        return m_p;
    }

    T &operator* () const
    {
        assert(m_p != 0);
        return *m_p;
    }

    T *get() const
    {
        return m_p;
    }

    typedef T * Pointer::*unspecified_bool_type;

    operator unspecified_bool_type () const
    {
        return m_p == 0 ? 0 : &Pointer::m_p;
    }

    Pointer &operator= (const Pointer &p)
    {
        Pointer(p).swap(*this);
        return *this;
    }

    template<typename U> Pointer &operator= (const Pointer<U> &p)
    {
        Pointer(p).swap(*this);
        return *this;
    }

private:
    T *m_p;

    void swap(Pointer &p)
    {
        T *temp = m_p;
        m_p = p.m_p;
        p.m_p = temp;
    }

    template<typename U> friend void swap(Pointer<U> &lhs, Pointer<U> &rhs);
};

template<typename T, typename U> inline bool operator== (const Pointer<T> &lhs, const Pointer<U> &rhs)
{
    return lhs.get() == rhs.get();
}

template<typename T, typename U> inline bool operator!= (const Pointer<T> &lhs, const Pointer<U> &rhs)
{
    return lhs.get() != rhs.get();
}

template<typename T, typename U> inline bool operator== (const Pointer<T> &lhs, U *rhs)
{
    return lhs.get() == rhs;
}

template<typename T, typename U> inline bool operator!= (const Pointer<T> &lhs, U *rhs)
{
    return lhs.get() != rhs;
}

template<typename T, typename U> inline bool operator== (T *lhs, const Pointer<U> &rhs)
{
    return lhs == rhs.get();
}

template<typename T, typename U> inline bool operator!= (T *lhs, const Pointer<U> &rhs)
{
    return lhs != rhs.get();
}

template<typename T> inline bool operator< (const Pointer<T> &lhs, const Pointer<T> &rhs)
{
    return std::less<T>(lhs.get(), rhs.get());
}

template<typename U> void swap(Pointer<U> &lhs, Pointer<U> &rhs)
{
    lhs.swap(rhs);
}

class OMGUI_API RefCountable
{
public:
    RefCountable() { }
    virtual ~RefCountable() { }

    virtual void add_ref() = 0;
    virtual void release() = 0;
};

class OMGUI_API RefCounted : public RefCountable
{
public:
    RefCounted();

    void add_ref();
    void release();

private:
    int m_ref_count;
};

}

void OMGUI_API intrusive_ptr_add_ref(omgui::RefCountable *countable);

void OMGUI_API intrusive_ptr_release(omgui::RefCountable *countable);

#endif

---