FM / smart

/usr/include/boost/smart_ptr

Name	Size	Mode	Actions
detail/	-	0755	rm
allocate_local_shared_array.hpp	5655	0644	edit dl rm
allocate_shared_array.hpp	9959	0644	edit dl rm
allocate_unique.hpp	12369	0644	edit dl rm
atomic_shared_ptr.hpp	5815	0644	edit dl rm
bad_weak_ptr.hpp	1744	0644	edit dl rm
enable_shared_from.hpp	1184	0644	edit dl rm
enable_shared_from_raw.hpp	4479	0644	edit dl rm
enable_shared_from_this.hpp	2175	0644	edit dl rm
intrusive_ptr.hpp	9427	0644	edit dl rm
intrusive_ref_counter.hpp	5817	0644	edit dl rm
local_shared_ptr.hpp	19377	0644	edit dl rm
make_local_shared.hpp	576	0644	edit dl rm
make_local_shared_array.hpp	2179	0644	edit dl rm
make_local_shared_object.hpp	4787	0644	edit dl rm
make_shared.hpp	707	0644	edit dl rm
make_shared_array.hpp	1996	0644	edit dl rm
make_shared_object.hpp	24622	0644	edit dl rm
make_unique.hpp	1783	0644	edit dl rm
owner_equal_to.hpp	671	0644	edit dl rm
owner_hash.hpp	600	0644	edit dl rm
owner_less.hpp	853	0644	edit dl rm
scoped_array.hpp	3301	0644	edit dl rm
scoped_ptr.hpp	4082	0644	edit dl rm
shared_array.hpp	7252	0644	edit dl rm
shared_ptr.hpp	31199	0644	edit dl rm
weak_ptr.hpp	7582	0644	edit dl rm

Edit: /usr/include/boost/smart_ptr/atomic_shared_ptr.hpp (5815B)

#ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED
#define BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED

//
//  atomic_shared_ptr.hpp
//
//  Copyright 2017 Peter Dimov
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  See http://www.boost.org/libs/smart_ptr/ for documentation.
//

#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/smart_ptr/detail/spinlock.hpp>
#include <cstring>

namespace boost
{

template<class T> class atomic_shared_ptr
{
private:

boost::shared_ptr<T> p_;

mutable boost::detail::spinlock l_;

atomic_shared_ptr(const atomic_shared_ptr&);
    atomic_shared_ptr& operator=(const atomic_shared_ptr&);

private:

bool compare_exchange( shared_ptr<T>& v, shared_ptr<T> w ) BOOST_SP_NOEXCEPT
    {
        l_.lock();

if( p_._internal_equiv( v ) )
        {
            p_.swap( w );

l_.unlock();
            return true;
        }
        else
        {
            shared_ptr<T> tmp( p_ );

l_.unlock();

tmp.swap( v );
            return false;
        }
    }

public:

#if !defined( BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX ) && !defined( BOOST_NO_CXX11_CONSTEXPR )

constexpr atomic_shared_ptr() BOOST_SP_NOEXCEPT: l_ BOOST_DETAIL_SPINLOCK_INIT
    {
    }

atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
        : p_( std::move( p ) ), l_ BOOST_DETAIL_SPINLOCK_INIT
    {
    }

#else

atomic_shared_ptr() BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
        std::memcpy( &l_, &init, sizeof( init ) );
    }

atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
        : p_( std::move( p ) )
#else
        : p_( p )
#endif
    {
        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
        std::memcpy( &l_, &init, sizeof( init ) );
    }

#endif

atomic_shared_ptr& operator=( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock::scoped_lock lock( l_ );
        p_.swap( r );

return *this;
    }

BOOST_CONSTEXPR bool is_lock_free() const BOOST_SP_NOEXCEPT
    {
        return false;
    }

shared_ptr<T> load() const BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock::scoped_lock lock( l_ );
        return p_;
    }

template<class M> shared_ptr<T> load( M ) const BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock::scoped_lock lock( l_ );
        return p_;
    }

operator shared_ptr<T>() const BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock::scoped_lock lock( l_ );
        return p_;
    }

void store( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock::scoped_lock lock( l_ );
        p_.swap( r );
    }

template<class M> void store( shared_ptr<T> r, M ) BOOST_SP_NOEXCEPT
    {
        boost::detail::spinlock::scoped_lock lock( l_ );
        p_.swap( r );
    }

shared_ptr<T> exchange( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
    {
        {
            boost::detail::spinlock::scoped_lock lock( l_ );
            p_.swap( r );
        }

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

return std::move( r );

#else

return r;

#endif
    }

template<class M> shared_ptr<T> exchange( shared_ptr<T> r, M ) BOOST_SP_NOEXCEPT
    {
        {
            boost::detail::spinlock::scoped_lock lock( l_ );
            p_.swap( r );
        }

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

return std::move( r );

#else

return r;

#endif
    }

template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, w );
    }

template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, w );
    }

bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, w );
    }

template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, w );
    }

template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, w );
    }

bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, w );
    }

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, std::move( w ) );
    }

template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, std::move( w ) );
    }

bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, std::move( w ) );
    }

template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, std::move( w ) );
    }

template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, std::move( w ) );
    }

bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w ) BOOST_SP_NOEXCEPT
    {
        return compare_exchange( v, std::move( w ) );
    }

#endif
};

} // namespace boost

#endif  // #ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED

#ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED #define BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED // // atomic_shared_ptr.hpp // // Copyright 2017 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/ for documentation. // #include #include #include namespace boost { template class atomic_shared_ptr { private: boost::shared_ptr p_; mutable boost::detail::spinlock l_; atomic_shared_ptr(const atomic_shared_ptr&); atomic_shared_ptr& operator=(const atomic_shared_ptr&); private: bool compare_exchange( shared_ptr& v, shared_ptr w ) BOOST_SP_NOEXCEPT { l_.lock(); if( p_._internal_equiv( v ) ) { p_.swap( w ); l_.unlock(); return true; } else { shared_ptr tmp( p_ ); l_.unlock(); tmp.swap( v ); return false; } } public: #if !defined( BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX ) && !defined( BOOST_NO_CXX11_CONSTEXPR ) constexpr atomic_shared_ptr() BOOST_SP_NOEXCEPT: l_ BOOST_DETAIL_SPINLOCK_INIT { } atomic_shared_ptr( shared_ptr p ) BOOST_SP_NOEXCEPT : p_( std::move( p ) ), l_ BOOST_DETAIL_SPINLOCK_INIT { } #else atomic_shared_ptr() BOOST_SP_NOEXCEPT { boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT; std::memcpy( &l_, &init, sizeof( init ) ); } atomic_shared_ptr( shared_ptr p ) BOOST_SP_NOEXCEPT #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) : p_( std::move( p ) ) #else : p_( p ) #endif { boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT; std::memcpy( &l_, &init, sizeof( init ) ); } #endif atomic_shared_ptr& operator=( shared_ptr r ) BOOST_SP_NOEXCEPT { boost::detail::spinlock::scoped_lock lock( l_ ); p_.swap( r ); return *this; } BOOST_CONSTEXPR bool is_lock_free() const BOOST_SP_NOEXCEPT { return false; } shared_ptr load() const BOOST_SP_NOEXCEPT { boost::detail::spinlock::scoped_lock lock( l_ ); return p_; } template shared_ptr load( M ) const BOOST_SP_NOEXCEPT { boost::detail::spinlock::scoped_lock lock( l_ ); return p_; } operator shared_ptr() const BOOST_SP_NOEXCEPT { boost::detail::spinlock::scoped_lock lock( l_ ); return p_; } void store( shared_ptr r ) BOOST_SP_NOEXCEPT { boost::detail::spinlock::scoped_lock lock( l_ ); p_.swap( r ); } template void store( shared_ptr r, M ) BOOST_SP_NOEXCEPT { boost::detail::spinlock::scoped_lock lock( l_ ); p_.swap( r ); } shared_ptr exchange( shared_ptr r ) BOOST_SP_NOEXCEPT { { boost::detail::spinlock::scoped_lock lock( l_ ); p_.swap( r ); } #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) return std::move( r ); #else return r; #endif } template shared_ptr exchange( shared_ptr r, M ) BOOST_SP_NOEXCEPT { { boost::detail::spinlock::scoped_lock lock( l_ ); p_.swap( r ); } #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) return std::move( r ); #else return r; #endif } template bool compare_exchange_weak( shared_ptr& v, const shared_ptr& w, M, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, w ); } template bool compare_exchange_weak( shared_ptr& v, const shared_ptr& w, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, w ); } bool compare_exchange_weak( shared_ptr& v, const shared_ptr& w ) BOOST_SP_NOEXCEPT { return compare_exchange( v, w ); } template bool compare_exchange_strong( shared_ptr& v, const shared_ptr& w, M, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, w ); } template bool compare_exchange_strong( shared_ptr& v, const shared_ptr& w, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, w ); } bool compare_exchange_strong( shared_ptr& v, const shared_ptr& w ) BOOST_SP_NOEXCEPT { return compare_exchange( v, w ); } #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) template bool compare_exchange_weak( shared_ptr& v, shared_ptr&& w, M, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, std::move( w ) ); } template bool compare_exchange_weak( shared_ptr& v, shared_ptr&& w, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, std::move( w ) ); } bool compare_exchange_weak( shared_ptr& v, shared_ptr&& w ) BOOST_SP_NOEXCEPT { return compare_exchange( v, std::move( w ) ); } template bool compare_exchange_strong( shared_ptr& v, shared_ptr&& w, M, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, std::move( w ) ); } template bool compare_exchange_strong( shared_ptr& v, shared_ptr&& w, M ) BOOST_SP_NOEXCEPT { return compare_exchange( v, std::move( w ) ); } bool compare_exchange_strong( shared_ptr& v, shared_ptr&& w ) BOOST_SP_NOEXCEPT { return compare_exchange( v, std::move( w ) ); } #endif }; } // namespace boost #endif // #ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED