boostorg/smart_ptr
1
0
Fork 1
mirror of https://github.com/boostorg/smart_ptr.git synced 2025-07-29 20:37:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove uses of BOOST_SP_NOEXCEPT from weak_ptr.hpp

Browse Source
This commit is contained in:
Peter Dimov
2024-10-02 21:43:54 +03:00
parent f866c6a9ae
commit c4fed8ca7f
1 changed files with 31 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
include/boost/smart_ptr/weak_ptr.hpp
View File

@ -15,7 +15,6 @@
#include <boost/smart_ptr/detail/shared_count.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/smart_ptr/detail/sp_noexcept.hpp>
#include <memory>
#include <cstddef>
@ -33,18 +32,18 @@ public:
typedef typename boost::detail::sp_element< T >::type element_type;
BOOST_CONSTEXPR weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn()
BOOST_CONSTEXPR weak_ptr() noexcept : px(0), pn()
{
}
// generated copy constructor, assignment, destructor are fine...
// ... except in C++0x, move disables the implicit copy
weak_ptr( weak_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
weak_ptr( weak_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
{
}
weak_ptr & operator=( weak_ptr const & r ) BOOST_SP_NOEXCEPT
weak_ptr & operator=( weak_ptr const & r ) noexcept
{
px = r.px;
pn = r.pn;
@ -70,14 +69,14 @@ public:
template<class Y>
weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
BOOST_SP_NOEXCEPT : px(r.lock().get()), pn(r.pn)
noexcept : px(r.lock().get()), pn(r.pn)
{
boost::detail::sp_assert_convertible< Y, T >();
}
template<class Y>
weak_ptr( weak_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
BOOST_SP_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
noexcept : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
{
boost::detail::sp_assert_convertible< Y, T >();
r.px = 0;
@ -85,13 +84,13 @@ public:
// for better efficiency in the T == Y case
weak_ptr( weak_ptr && r )
BOOST_SP_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
noexcept : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
{
r.px = 0;
}
// for better efficiency in the T == Y case
weak_ptr & operator=( weak_ptr && r ) BOOST_SP_NOEXCEPT
weak_ptr & operator=( weak_ptr && r ) noexcept
{
this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
return *this;
@ -100,26 +99,26 @@ public:
template<class Y>
weak_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
noexcept : px( r.px ), pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
}
// aliasing
template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) BOOST_SP_NOEXCEPT: px( p ), pn( r.pn )
template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) noexcept: px( p ), pn( r.pn )
{
}
template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) BOOST_SP_NOEXCEPT: px( p ), pn( r.pn )
template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) noexcept: px( p ), pn( r.pn )
{
}
template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) BOOST_SP_NOEXCEPT: px( p ), pn( std::move( r.pn ) )
template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) noexcept: px( p ), pn( std::move( r.pn ) )
{
}
template<class Y>
weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
weak_ptr & operator=( weak_ptr<Y> const & r ) noexcept
{
boost::detail::sp_assert_convertible< Y, T >();
@ -130,14 +129,14 @@ public:
}
template<class Y>
weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_SP_NOEXCEPT
weak_ptr & operator=( weak_ptr<Y> && r ) noexcept
{
this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
template<class Y>
weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
weak_ptr & operator=( shared_ptr<Y> const & r ) noexcept
{
boost::detail::sp_assert_convertible< Y, T >();
@ -147,63 +146,63 @@ public:
return *this;
}
shared_ptr<T> lock() const BOOST_SP_NOEXCEPT
shared_ptr<T> lock() const noexcept
{
return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
}
long use_count() const BOOST_SP_NOEXCEPT
long use_count() const noexcept
{
return pn.use_count();
}
bool expired() const BOOST_SP_NOEXCEPT
bool expired() const noexcept
{
return pn.use_count() == 0;
}
bool _empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
bool _empty() const noexcept // extension, not in std::weak_ptr
{
return pn.empty();
}
bool empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
bool empty() const noexcept // extension, not in std::weak_ptr
{
return pn.empty();
}
void reset() BOOST_SP_NOEXCEPT
void reset() noexcept
{
this_type().swap(*this);
}
void swap(this_type & other) BOOST_SP_NOEXCEPT
void swap(this_type & other) noexcept
{
std::swap(px, other.px);
pn.swap(other.pn);
}
template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const noexcept
{
return pn == rhs.pn;
}
template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const noexcept
{
return pn == rhs.pn;
}
std::size_t owner_hash_value() const BOOST_SP_NOEXCEPT
std::size_t owner_hash_value() const noexcept
{
return pn.hash_value();
}
@ -218,12 +217,12 @@ private:
}; // weak_ptr
template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_SP_NOEXCEPT
template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) noexcept
{
return a.owner_before( b );
}
template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_SP_NOEXCEPT
template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept
{
a.swap(b);
}
@ -236,7 +235,7 @@ template<class T> weak_ptr( shared_ptr<T> ) -> weak_ptr<T>;
// hash_value
template< class T > std::size_t hash_value( boost::weak_ptr<T> const & p ) BOOST_SP_NOEXCEPT
template< class T > std::size_t hash_value( boost::weak_ptr<T> const & p ) noexcept
{
return p.owner_hash_value();
}
@ -250,7 +249,7 @@ namespace std
template<class T> struct hash< ::boost::weak_ptr<T> >
{
std::size_t operator()( ::boost::weak_ptr<T> const & p ) const BOOST_SP_NOEXCEPT
std::size_t operator()( ::boost::weak_ptr<T> const & p ) const noexcept
{
return p.owner_hash_value();
}
@ -258,7 +257,7 @@ template<class T> struct hash< ::boost::weak_ptr<T> >
template<class T> struct equal_to< ::boost::weak_ptr<T> >
{
bool operator()( ::boost::weak_ptr<T> const & a, ::boost::weak_ptr<T> const & b ) const BOOST_SP_NOEXCEPT
bool operator()( ::boost::weak_ptr<T> const & a, ::boost::weak_ptr<T> const & b ) const noexcept
{
return a.owner_equals( b );
}