// Copyright (C) 2007  Davis E. King (davisking@users.sourceforge.net)
// License: Boost Software License   See LICENSE.txt for the full license.
#undef DLIB_WEAK_PTr_ABSTRACT_
#ifdef DLIB_WEAK_PTr_ABSTRACT_ 

#include "shared_ptr_abstract.h"

namespace dlib {

    template <
        typename T
        > 
    class weak_ptr 
    {

        /*!
            INITIAL VALUE
                defined by constructor

            WHAT THIS OBJECT REPRESENTS
                The weak_ptr class template stores a weak reference to an object that is 
                already managed by a shared_ptr. To access the object, a weak_ptr can 
                be converted to a shared_ptr using the member function lock().  

                This is an implementation of the std::tr1::weak_ptr template from the 
                document ISO/IEC PDTR 19768, Proposed Draft Technical Report on C++
                Library Extensions.  The only deviation from that document is that this 
                shared_ptr is declared inside the dlib namespace rather than std::tr1.
        !*/

    public:
        typedef T element_type;

        weak_ptr(
        );
        /*!
            ensures
                - #use_count() == 0
                - creates an empty weak_ptr
        !*/

        template<typename Y> 
        weak_ptr(
            const shared_ptr<Y>& r
        );
        /*!
            requires
                - Y* must be convertible to T*
            ensures
                - if (r is empty) then
                    - constructs an empty weak_ptr object
                - else 
                    - constructs a weak_ptr object that shares ownership with r and 
                      stores a copy of the pointer stored in r.
                - #use_count() == #r.use_count()
        !*/

        weak_ptr(
            const weak_ptr& r
        );
        /*!
            ensures
                - if (r is empty) then
                    - constructs an empty weak_ptr object
                - else 
                    - constructs a weak_ptr object that shares ownership with r and 
                      stores a copy of the pointer stored in r.
                - #use_count() == #r.use_count()
        !*/

        template<typename Y> 
        weak_ptr(
            const weak_ptr<Y>& r
        );
        /*!
            requires
                - Y* must be convertible to T*
            ensures
                - if (r is empty) then
                    - constructs an empty weak_ptr object
                - else 
                    - constructs a weak_ptr object that shares ownership with r and 
                      stores a copy of the pointer stored in r.
                - #use_count() == #r.use_count()
        !*/

        ~weak_ptr(
        );
        /*!
            ensures
                - destroys this weak_ptr object but has no effect on the object its 
                  stored pointer points to.
        !*/

        weak_ptr& operator= (
            const weak_ptr& r
        );
        /*!
            ensures
                - equivalent to weak_ptr(r).swap(*this)
        !*/

        template<typename Y> 
        weak_ptr& operator= (
            const weak_ptr<Y>& r
        );
        /*!
            requires
                - Y* must be convertible to T*
            ensures
                - equivalent to weak_ptr(r).swap(*this)
        !*/

        template<typename Y> 
        weak_ptr& operator=(
            const shared_ptr<Y>& r
        );
        /*!
            requires
                - Y* must be convertible to T*
            ensures
                - equivalent to weak_ptr(r).swap(*this)
        !*/

        long use_count(
        ) const;
        /*!
            ensures
                - if (*this is empty) then
                    - returns 0
                - else 
                    - returns the number of shared_ptr instances that share ownership 
                      with *this
        !*/

        bool expired(
        ) const;
        /*!
            ensures
                - returns (use_count() == 0)
        !*/

        shared_ptr<T> lock(
        ) const;
        /*!
            ensures
                - if (expired()) then
                    - returns shared_ptr<T>()
                - else
                    - returns shared_ptr<T>(*this)
        !*/

        void reset(
        );
        /*!
            ensures
                - equivalent to weak_ptr().swap(*this)
        !*/

        void swap(
            weak_ptr<T>& b
        );
        /*!
            ensures
                - swaps *this and item
        !*/

    };

    template<typename T, typename U>
    bool operator< (
        const weak_ptr<T>& a, 
        const weak_ptr<U>& b
    );
    /*!
        ensures
            - Defines an operator< on shared_ptr types appropriate for use in the associative 
              containers.  
    !*/

    template<typename T>
    void swap(
        weak_ptr<T>& a, 
        weak_ptr<T> & b
    ) { a.swap(b); }
    /*!
        provides a global swap function
    !*/
}

#endif // DLIB_WEAK_PTr_ABSTRACT_


