coco
194 lines
5.0 KiB
C++
194 lines
5.0 KiB
C++
// Copyright (C) 2007 Davis E. King (davis@dlib.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_
|
|
|
|
|