toast/unintrusive_ptr.hpp

Go to the documentation of this file.

#ifndef toast_unintrusive_ptr_hpp_INCLUDED
#define toast_unintrusive_ptr_hpp_INCLUDED

#include <iostream>
#include <algorithm>

#include <boost/static_assert.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_convertible.hpp>

#include <toast/detail/unintrusive_impl.hpp>

namespace toast {

template<class T>
class unintrusive_ptr;

namespace detail {

template<class T>
int get_use_count(unintrusive_ptr<T> const &x)
{
        return x.use_count();
}

template<class T>
bool get_unique(unintrusive_ptr<T> const &x)
{
        return x.unique();
}

}

template<class T>
class weak_unintrusive_ptr;

template<class T>
class enable_unintrusive_from_this;

template<class T>
class unintrusive_ptr
{
        typedef detail::weak_count_wrapper<T> real_weak_wrapper_t;
        typedef detail::count_wrapper<T> real_wrapper_t;
public:
        typedef T element_type;
        
        typedef T*(unintrusive_ptr<T>::*unspecified_bool_type)() const;

        unintrusive_ptr()
        {
                set_new_wrapper(detail::the_zero_wrapper());
        }
        
        template<class TypedInPlaceFactory>
                unintrusive_ptr(TypedInPlaceFactory const &factory)
        {
                build_new_wrapper(factory);
        }

        unintrusive_ptr(unintrusive_ptr const &toCopy)
        {
                set_new_wrapper(toCopy.m_wrapper);
        }

        template<class Y>
                unintrusive_ptr(unintrusive_ptr<Y> const &other)
        {
                BOOST_STATIC_ASSERT((boost::is_convertible<Y*, T*>::value) || (boost::is_convertible<T*, Y*>::value));
                detail::program_startup_multiple_inheritance_check<T, Y>::instantiate_template();

                set_new_wrapper(other.m_wrapper);
        }
        
        template<class Y>
    explicit unintrusive_ptr(weak_unintrusive_ptr<Y> const & r)
    {
                real_wrapper_t* r_real_wrapper = static_cast<real_weak_wrapper_t*>(r.m_wrapper)->m_real_wrapper;
                
                if(r_real_wrapper == NULL)
                        throw bad_weak_unintrusive_ptr();
                        
                set_new_wrapper(r_real_wrapper);
    }


        unintrusive_ptr& operator=(unintrusive_ptr const &target)
        {
                return operator=<T>(target);
        }

        template<class Y>
        unintrusive_ptr<T>& operator=(unintrusive_ptr<Y> const &target)
        {
                BOOST_STATIC_ASSERT((boost::is_convertible<Y*, T*>::value) || (boost::is_convertible<T*, Y*>::value));
                detail::program_startup_multiple_inheritance_check<T, Y>::instantiate_template();

                unintrusive_ptr<T>(target).swap(*this);
                return *this;
        }
        
        ~unintrusive_ptr()
        {
                decrement();
        }

        void reset()
        {
                decrement();
                set_new_wrapper(detail::the_zero_wrapper());
        }
        
        template<class TypedInPlaceFactory>
                void reset(TypedInPlaceFactory const &factory)
        {
                typedef detail::count_wrapper<T> real_wrapper_t;
                
                decrement();
                build_new_wrapper(factory);
        }

        T& operator*() const
    {
                return *get();
        }

    T* operator->() const
    {
                return static_cast<T*>
                        (static_cast<real_wrapper_t*>(m_wrapper)->stored_object());
        }

    T* get() const
    {
                if(!is_null())
                        return static_cast<T*>(static_cast<real_wrapper_t*>(m_wrapper)->stored_object());
                else
                        return NULL;
        }

    operator unspecified_bool_type() const
    {
                return is_null() ? NULL : &unintrusive_ptr<T>::get;
        }

    void swap(unintrusive_ptr<T>& other)
    {
                std::swap(m_wrapper, other.m_wrapper);
        }

private:
    bool unique() const
    {
                return !is_null() ? m_wrapper->count() == 1 : false;
    }

    long use_count() const
    {
                return !is_null() ? m_wrapper->count() : 0;
        }
        
        // Special constructor for use by weak_unintrusive_ptr
    explicit unintrusive_ptr(detail::count_wrapper_base* wrapper)
        {
                set_new_wrapper(wrapper);
        }

    template<class TypedInPlaceFactory>
                void build_new_wrapper(TypedInPlaceFactory const &factory)
        {
                typedef detail::count_wrapper<typename TypedInPlaceFactory::value_type> real_wrapper_t;
                
                real_wrapper_t* tmp = new real_wrapper_t;
                tmp->init(factory);

                m_wrapper = tmp;

                optionally_setup_internal_weak_this_p<TypedInPlaceFactory>(get());
        }

    template<class TypedInPlaceFactory>
    void optionally_setup_internal_weak_this_p(typename boost::disable_if<
                                                                                           boost::is_base_of<
                                                                                           enable_unintrusive_from_this<typename TypedInPlaceFactory::value_type>,
                                                                                           typename TypedInPlaceFactory::value_type> >::type* = 0)
    {
    }

    template<class TypedInPlaceFactory>
    void optionally_setup_internal_weak_this_p(typename boost::enable_if<
                                                                                           boost::is_base_of<
                                                                                           enable_unintrusive_from_this<typename TypedInPlaceFactory::value_type>,
                                                                                           typename TypedInPlaceFactory::value_type> >::type* = 0)
    {
                get()->_internal_weak_this = *this;
    }
        
        void destroy_wrapper()
        {
                static_cast<T*>(static_cast<real_wrapper_t*>(m_wrapper)->stored_object())->~T();

                // Have to do this here because count_wrapper can't have
                // a destructor to remain POD
        static_cast<real_weak_wrapper_t*>
                (static_cast<real_wrapper_t*>(m_wrapper)->m_weak_wrapper)
                ->
                m_real_wrapper = NULL;
                
        m_wrapper->destroy_self(m_wrapper);
        set_new_wrapper(detail::the_zero_wrapper());
        }
        
    void decrement()
    {
                if(m_wrapper->decrement() == 0) {
                        destroy_wrapper();
                        return;
                }
        }

    void set_new_wrapper(detail::count_wrapper_base* new_wrapper)
    {
                new_wrapper->increment();
                m_wrapper = new_wrapper;
    }

        bool is_null() const
        {
                return m_wrapper == detail::the_zero_wrapper();
        }


        detail::count_wrapper_base* m_wrapper;

        template<class Y>
                friend class unintrusive_ptr;

        friend class weak_unintrusive_ptr<T>;

        template<class Y>
        friend int detail::get_use_count(unintrusive_ptr<Y> const &x);

        template<class Y>
        friend bool detail::get_unique(unintrusive_ptr<Y> const &x);

        template<class X, class Y>
                friend unintrusive_ptr<X> static_pointer_cast(unintrusive_ptr<Y> const & r);

        template<class X, class Y>
                friend unintrusive_ptr<X> const_pointer_cast(unintrusive_ptr<Y> const & r);

        template<class X, class Y>
                friend unintrusive_ptr<X> dynamic_pointer_cast(unintrusive_ptr<Y> const & r);

        template<class X, class Y>
        friend bool operator==(unintrusive_ptr<X> const & a, unintrusive_ptr<Y> const & b);
        
        template<class X, class Y>
        friend bool operator!=(unintrusive_ptr<X> const & a, unintrusive_ptr<Y> const & b);

        template<class X, class Y>
        friend bool operator<(unintrusive_ptr<X> const & a, unintrusive_ptr<Y> const & b);
};

template<class X, class Y>
        bool operator==(unintrusive_ptr<X> const & a, unintrusive_ptr<Y> const & b)
{
        return a.get() == b.get();
}

template<class X, class Y>
  bool operator!=(unintrusive_ptr<X> const & a, unintrusive_ptr<Y> const & b)
{
        return a.get() != b.get();
}

template<class X, class Y>
  bool operator<(unintrusive_ptr<X> const & a, unintrusive_ptr<Y> const & b)
{
        return a.m_wrapper < b.m_wrapper;
}

template<class T>
void swap(unintrusive_ptr<T> & a, unintrusive_ptr<T> & b)
{
        a.swap(b);
}

template<class T>
T* get_pointer(unintrusive_ptr<T> const & p)
{
        return p.get();
}

template<class T, class U>
unintrusive_ptr<T> static_pointer_cast(unintrusive_ptr<U> const & r)
{
        (void)static_cast<T*>((U*)0); // Check that a normal static cast would work
        return unintrusive_ptr<T>(r.m_wrapper);
}

template<class T, class U>
unintrusive_ptr<T> const_pointer_cast(unintrusive_ptr<U> const & r)
{
        (void)const_cast<T*>((U* const)0); // Check that a normal const cast would work
        return unintrusive_ptr<T>(r.m_wrapper);
}

template<class T, class U>
  unintrusive_ptr<T> dynamic_pointer_cast(unintrusive_ptr<U> const & r)
{
        if(dynamic_cast<T*>(r.get()))
                return unintrusive_ptr<T>(r);

        return unintrusive_ptr<T>();
}

}

#endif

---