toast/weak_unintrusive_ptr.hpp

Go to the documentation of this file.

#ifndef toast_weak_unintrusive_ptr_hpp_INCLUDED
#define toast_weak_unintrusive_ptr_hpp_INCLUDED

#include <toast/unintrusive_ptr.hpp>
#include <toast/detail/unintrusive_impl.hpp>

#include <algorithm>

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>

namespace toast {

template<class T>
class unintrusive_ptr;

template<class T>
class weak_unintrusive_ptr
{
        typedef detail::count_wrapper<T> real_count_wrapper_t;
        typedef detail::weak_count_wrapper<T> real_wrapper_t;
        
public:
        typedef T element_type;

        weak_unintrusive_ptr()
        {
                set_new_wrapper(detail::the_weak_zero_wrapper());
        }

        weak_unintrusive_ptr(weak_unintrusive_ptr const & r)
        {
                set_new_wrapper(r.m_wrapper);
        }

        template<class Y>
        explicit weak_unintrusive_ptr(weak_unintrusive_ptr<Y> const & r)
        {
                BOOST_STATIC_ASSERT((boost::is_convertible<Y*, T*>::value));

                set_new_wrapper(r.m_wrapper);
        }

        template<class Y>
        weak_unintrusive_ptr(unintrusive_ptr<Y> const & r)
        {
                BOOST_STATIC_ASSERT((boost::is_convertible<Y*, T*>::value));
                
                real_count_wrapper_t* unintrusive_wrapper = static_cast<real_count_wrapper_t*>(r.m_wrapper);
                
                if(unintrusive_wrapper->m_weak_wrapper == detail::the_weak_zero_wrapper())
                        unintrusive_wrapper->m_weak_wrapper = new detail::weak_count_wrapper<Y>(unintrusive_wrapper);

                set_new_wrapper(unintrusive_wrapper->m_weak_wrapper);
        }       

        ~weak_unintrusive_ptr()
        {
                decrement();
        };

        weak_unintrusive_ptr& operator=(weak_unintrusive_ptr const & r)
        {
                decrement();
                set_new_wrapper(r.m_wrapper);

                return *this;
        }
        
        template<class Y>
        weak_unintrusive_ptr& operator=(weak_unintrusive_ptr<Y> const & r)
        {
                (void)static_cast<T*>((Y*)NULL);
                
                decrement();
                set_new_wrapper(r.m_wrapper);
        }
        
        template<class Y>
        weak_unintrusive_ptr& operator=(unintrusive_ptr<Y> const & r)
        {
                real_count_wrapper_t* unintrusive_wrapper = static_cast<real_count_wrapper_t*>(r.m_wrapper);
                
                (void)static_cast<T*>((Y*)NULL);
                
                decrement();
                
                if(unintrusive_wrapper->m_weak_wrapper == detail::the_weak_zero_wrapper())
                        unintrusive_wrapper->m_weak_wrapper = new detail::weak_count_wrapper<Y>(unintrusive_wrapper);

                detail::weak_count_wrapper_base* new_wrapper = static_cast<real_count_wrapper_t*>(r.m_wrapper)->m_weak_wrapper;
                set_new_wrapper(new_wrapper);

                return *this;
        }

        long use_count() const
        {
                return m_wrapper->count();
        }
        
        bool expired() const
        {
                return static_cast<real_wrapper_t*>(m_wrapper)->expired();
        }
        
        unintrusive_ptr<T> lock() const
        {
                if(expired())
                        return unintrusive_ptr<T>();

                return unintrusive_ptr<T>(static_cast<detail::count_wrapper_base*>
                                                                  (static_cast<real_wrapper_t*>(m_wrapper)
                                                                   ->m_real_wrapper));
        }

        void reset()
        {
                decrement();
                set_new_wrapper(detail::the_weak_zero_wrapper());
        }
        
        void swap(weak_unintrusive_ptr<T> & b)
        {
                std::swap(m_wrapper, b.m_wrapper);
        }

private:
        void decrement()
        {
                if(m_wrapper->decrement() == 0) {
                        delete m_wrapper;
                        set_new_wrapper(detail::the_weak_zero_wrapper());
                        return;
                }
        }

        void set_new_wrapper(detail::weak_count_wrapper_base* new_wrapper)
        {
                new_wrapper->increment();
                m_wrapper = new_wrapper;
        }
        
        template<int n>
        friend class count_wrapper;

        template<class Y>
        friend class unintrusive_ptr;
        
        detail::weak_count_wrapper_base* m_wrapper;
};

template<class T, class U>
bool operator<(weak_unintrusive_ptr<T> const & a, weak_unintrusive_ptr<U> const & b)
{
        return a.m_wrapper < b.m_wrapper;
}

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

}

#endif

---