diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 0d840cc..16e0744 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -27,6 +27,19 @@ "command": "${workspaceRoot}/.vscode/msvc.bat && cd ${workspaceRoot}/bld/debug && meson test" } }, + { + "group": "test", + "label": "Run all unit tests (b2, all configurations)", + "type": "shell", + "command": "../../b2 test link=shared,static variant=debug,release exception-handling=on,off cxxstd=11,14,1z,17", + "problemMatcher": { + "base": "$gcc", + "fileLocation": [ + "relative", + "${workspaceRoot}/bld/release" + ] + } + }, { "group": { "kind": "test", diff --git a/build/test/Jamfile.v2 b/build/test/Jamfile.v2 deleted file mode 100644 index 370ae14..0000000 --- a/build/test/Jamfile.v2 +++ /dev/null @@ -1,51 +0,0 @@ -# Copyright (c) 2015-2020 Emil Dotchevski and Reverge Studios, Inc. - -# 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) - -import testing ; -import path ; - -project - : source-location - ../../test - : requirements - 11 - static - gcc:"-Wno-dangling-else -Wno-sign_compare -w" - clang:"-Wno-delete-non-abstract-non-virtual-dtor -Wno-delete-non-virtual-dtor -Wno-dangling-else -w" - ; - -compile _hpp_compile_block_test.cpp ; -compile _hpp_compile_blocker_test.cpp ; -compile _hpp_compile_connect_test.cpp ; -compile _hpp_compile_connection_test.cpp ; -compile _hpp_compile_emit_test.cpp ; -compile _hpp_compile_thread_local_queue_test.cpp : multi ; -compile _hpp_compile_translate_test.cpp ; - -run args_connect_test.cpp ..//synapse ; -run args_translate_test.cpp ..//synapse ; -run block_emit_test.cpp ..//synapse ; -run block_test.cpp ..//block ; -run connect_emit_test.cpp ..//synapse ; -run connection_lifetime_test.cpp ..//synapse ; -run connection_user_data_test.cpp ..//synapse ; -run ct_basic_test.cpp ..//synapse : : : multi ; -run ct_lambda_test.cpp ..//synapse : : : multi ; -run ct_tlq_lifetime_test.cpp ..//synapse : : : multi ; -run ct_wait_test.cpp ..//synapse : : : multi ; -run emit_stub_test.cpp ..//emit ; -run emit_test.cpp ..//synapse ; -run property_test.cpp ..//synapse ; -run release_test.cpp ..//synapse ; -run shutdown_test1.cpp ..//synapse ; -run shutdown_test2.cpp ..//synapse ; -run shutdown_test3.cpp ..//synapse ; -run shutdown_test4.cpp ..//synapse ; -run shutdown_test5.cpp ..//synapse ; -run shutdown_test6.cpp ..//synapse ; -run shutdown_test7.cpp ..//synapse ; -run shutdown_test8.cpp ..//synapse ; -run shutdown_test9.cpp ..//synapse ; -run weak_store_test.cpp ; diff --git a/doc/synapse.adoc b/doc/synapse.adoc index cf7b24b..8b86a65 100644 --- a/doc/synapse.adoc +++ b/doc/synapse.adoc @@ -1361,10 +1361,6 @@ Because Synapse is formatted for Boost review, people often ask what are the dif == Macros and Configuration -=== `BOOST_SYNAPSE_USE_BOOST` - -If this macro is defined, Synapse will use `boost::shared_ptr`, `boost::weak_ptr` and `boost::function`. By default, it will use `std::shared_ptr`, `std::weak_ptr` and `std::function`. - === `BOOST_SYNAPSE_ASSERT` All assertions in Synapse use this macro. If it is not defined, Synapse header files `#define` it either as `BOOST_ASSERT` or `assert`, depending on whether `BOOST_SYNAPSE_USE_BOOST` is defined. diff --git a/example/glfw/glfw_synapsify.hpp b/example/glfw/glfw_synapsify.hpp index 6d565ba..5fe4779 100644 --- a/example/glfw/glfw_synapsify.hpp +++ b/example/glfw/glfw_synapsify.hpp @@ -53,7 +53,7 @@ class synapsifier // (when the connection expires). The emitter pointer passed to connect // (which in this case is of type GLFWwindow) is stored in the // synapse::connection object passed to the lambda below, and can be - // accessed by the connection::emitter member function template. + // accessed by the connection::emitter member std::function template. connect >( meta::emitter(), [setter]( connection & c, unsigned flags ) { diff --git a/include/boost/synapse/block.hpp b/include/boost/synapse/block.hpp index aeb9a6f..3f77255 100644 --- a/include/boost/synapse/block.hpp +++ b/include/boost/synapse/block.hpp @@ -24,13 +24,13 @@ namespace boost { namespace synapse { class blocker; template - shared_ptr block( Emitter * ); + std::shared_ptr block( Emitter * ); template - shared_ptr block( weak_ptr const & ); + std::shared_ptr block( std::weak_ptr const & ); template - shared_ptr block( shared_ptr const & ); + std::shared_ptr block( std::shared_ptr const & ); namespace meta { @@ -49,34 +49,38 @@ namespace boost { namespace synapse { namespace synapse_detail { - shared_ptr block_( shared_ptr const &, weak_store &&, int(*)(blocker &,bool) ); + std::shared_ptr block_( std::shared_ptr const &, weak_store &&, int(*)(blocker &,bool) ); template int emit_meta_blocked( blocker &, bool ); template - shared_ptr block_fwd( weak_store && e ) + std::shared_ptr block_fwd( weak_store && e ) { return block_(get_thread_local_signal_data(true),std::move(e),&emit_meta_blocked); } } template - shared_ptr block( Emitter * e ) + std::shared_ptr block( Emitter * e ) { return synapse_detail::block_fwd(e); } template - shared_ptr block( weak_ptr const & e ) + std::shared_ptr block( std::weak_ptr const & e ) { return synapse_detail::block_fwd(e); } template - shared_ptr block( shared_ptr const & e ) + std::shared_ptr block( std::shared_ptr const & e ) { return synapse_detail::block_fwd(e); } } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/blocker.hpp b/include/boost/synapse/blocker.hpp index 8d874b3..f22b52e 100644 --- a/include/boost/synapse/blocker.hpp +++ b/include/boost/synapse/blocker.hpp @@ -32,7 +32,7 @@ namespace boost { namespace synapse { public: - template shared_ptr emitter() const; + template std::shared_ptr emitter() const; }; } } @@ -42,11 +42,15 @@ namespace boost { namespace synapse { namespace boost { namespace synapse { template - shared_ptr blocker::emitter() const + std::shared_ptr blocker::emitter() const { return emitter_().maybe_lock(); } } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/connect.hpp b/include/boost/synapse/connect.hpp index 88e4796..ea032c3 100644 --- a/include/boost/synapse/connect.hpp +++ b/include/boost/synapse/connect.hpp @@ -24,49 +24,49 @@ namespace boost { namespace synapse { class connection; template - shared_ptr connect( Emitter *, F ); + std::shared_ptr connect( Emitter *, F ); template - shared_ptr connect( Emitter *, Receiver *, F ); + std::shared_ptr connect( Emitter *, Receiver *, F ); class pconnection; template - weak_ptr connect( weak_ptr const &, F ); + std::weak_ptr connect( std::weak_ptr const &, F ); template - weak_ptr connect( shared_ptr const &, F ); + std::weak_ptr connect( std::shared_ptr const &, F ); template - weak_ptr connect( Emitter *, weak_ptr const &, F ); + std::weak_ptr connect( Emitter *, std::weak_ptr const &, F ); template - weak_ptr connect( Emitter *, shared_ptr const &, F ); + std::weak_ptr connect( Emitter *, std::shared_ptr const &, F ); template - weak_ptr connect( weak_ptr const &, Receiver *, F ); + std::weak_ptr connect( std::weak_ptr const &, Receiver *, F ); template - weak_ptr connect( weak_ptr const &, weak_ptr const &, F ); + std::weak_ptr connect( std::weak_ptr const &, std::weak_ptr const &, F ); template - weak_ptr connect( weak_ptr const &, shared_ptr const &, F ); + std::weak_ptr connect( std::weak_ptr const &, std::shared_ptr const &, F ); template - weak_ptr connect( shared_ptr const &, Receiver *, F ); + std::weak_ptr connect( std::shared_ptr const &, Receiver *, F ); template - weak_ptr connect( shared_ptr const &, weak_ptr const &, F ); + std::weak_ptr connect( std::shared_ptr const &, std::weak_ptr const &, F ); template - weak_ptr connect( shared_ptr const &, shared_ptr const &, F ); + std::weak_ptr connect( std::shared_ptr const &, std::shared_ptr const &, F ); - shared_ptr release( weak_ptr const & ); - shared_ptr release( weak_ptr const & ); + std::shared_ptr release( std::weak_ptr const & ); + std::shared_ptr release( std::weak_ptr const & ); namespace meta { - weak_ptr emitter(); + std::weak_ptr emitter(); namespace connect_flags { unsigned const connecting=1; @@ -89,30 +89,30 @@ namespace boost { namespace synapse { namespace synapse_detail { - shared_ptr connect_( shared_ptr const &, weak_store && e, weak_store && r, shared_ptr const &, int(*)(connection &,unsigned) ); - shared_ptr pconnect_( shared_ptr const &, weak_store && e, weak_store && r, shared_ptr const &, int(*)(connection &,unsigned) ); + std::shared_ptr connect_( std::shared_ptr const &, weak_store && e, weak_store && r, std::shared_ptr const &, int(*)(connection &,unsigned) ); + std::shared_ptr pconnect_( std::shared_ptr const &, weak_store && e, weak_store && r, std::shared_ptr const &, int(*)(connection &,unsigned) ); //////////////////////////////////////////////////////// template - shared_ptr connect_fwd( weak_store && e, F f ) + std::shared_ptr connect_fwd( weak_store && e, F f ) { return connect_( get_thread_local_signal_data(true), std::move(e), weak_store(), - synapse::make_shared::signature> >(f), + std::make_shared::signature> >(f), &emit_meta_connected ); } template - shared_ptr pconnect_fwd( weak_store && e, F f ) + std::shared_ptr pconnect_fwd( weak_store && e, F f ) { return pconnect_( get_thread_local_signal_data(true), std::move(e), weak_store(), - synapse::make_shared::signature> >(f), + std::make_shared::signature> >(f), &emit_meta_connected ); } @@ -122,23 +122,23 @@ namespace boost { namespace synapse { template struct bind_front { - static shared_ptr connect_fwd( weak_store && e, weak_store && r, Rm (Receiver::*f)(Am...) ) + static std::shared_ptr connect_fwd( weak_store && e, weak_store && r, Rm (Receiver::*f)(Am...) ) { return connect_( get_thread_local_signal_data(true), std::move(e), std::move(r), - synapse::make_shared::signature> >([=]( A... a ) { return (r.maybe_lock().get()->*f)(a...); }), + std::make_shared::signature> >([=]( A... a ) { return (r.maybe_lock().get()->*f)(a...); }), &emit_meta_connected ); } - static shared_ptr pconnect_fwd( weak_store && e, weak_store && r, Rm (Receiver::*f)(Am...) ) + static std::shared_ptr pconnect_fwd( weak_store && e, weak_store && r, Rm (Receiver::*f)(Am...) ) { return pconnect_( get_thread_local_signal_data(true), std::move(e), std::move(r), - synapse::make_shared::signature> >([=]( A... a ) { return (r.maybe_lock().get()->*f)(a...); }), + std::make_shared::signature> >([=]( A... a ) { return (r.maybe_lock().get()->*f)(a...); }), &emit_meta_connected ); } }; @@ -146,100 +146,104 @@ namespace boost { namespace synapse { template struct bind_front { - static shared_ptr connect_fwd( weak_store && e, weak_store && r, F f ) + static std::shared_ptr connect_fwd( weak_store && e, weak_store && r, F f ) { return connect_( get_thread_local_signal_data(true), std::move(e), std::move(r), - synapse::make_shared::signature> >([=]( A... a ) { return f(&*r.maybe_lock(),a...); }), + std::make_shared::signature> >([=]( A... a ) { return f(&*r.maybe_lock(),a...); }), &emit_meta_connected ); } - static shared_ptr pconnect_fwd( weak_store && e, weak_store && r, F f ) + static std::shared_ptr pconnect_fwd( weak_store && e, weak_store && r, F f ) { return pconnect_( get_thread_local_signal_data(true), std::move(e), std::move(r), - synapse::make_shared::signature> >([=]( A... a ) { return f(&*r.maybe_lock(),a...); }), + std::make_shared::signature> >([=]( A... a ) { return f(&*r.maybe_lock(),a...); }), &emit_meta_connected ); } }; } template - shared_ptr connect( Emitter * e, F f ) + std::shared_ptr connect( Emitter * e, F f ) { return synapse_detail::connect_fwd(e,f); } template - shared_ptr connect( Emitter * e, Receiver * r, F f ) + std::shared_ptr connect( Emitter * e, Receiver * r, F f ) { return synapse_detail::bind_front::signature>::connect_fwd(e,r,f); } template - weak_ptr connect( weak_ptr const & e, F f ) + std::weak_ptr connect( std::weak_ptr const & e, F f ) { return synapse_detail::pconnect_fwd(e,f); } template - weak_ptr connect( shared_ptr const & e, F f ) + std::weak_ptr connect( std::shared_ptr const & e, F f ) { return synapse_detail::pconnect_fwd(e,f); } template - weak_ptr connect( Emitter * e, weak_ptr const & r, F f ) + std::weak_ptr connect( Emitter * e, std::weak_ptr const & r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( Emitter * e, shared_ptr const & r, F f ) + std::weak_ptr connect( Emitter * e, std::shared_ptr const & r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( weak_ptr const & e, Receiver * r, F f ) + std::weak_ptr connect( std::weak_ptr const & e, Receiver * r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( weak_ptr const & e, weak_ptr const & r, F f ) + std::weak_ptr connect( std::weak_ptr const & e, std::weak_ptr const & r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( weak_ptr const & e, shared_ptr const & r, F f ) + std::weak_ptr connect( std::weak_ptr const & e, std::shared_ptr const & r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( shared_ptr const & e, Receiver * r, F f ) + std::weak_ptr connect( std::shared_ptr const & e, Receiver * r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( shared_ptr const & e, weak_ptr const & r, F f ) + std::weak_ptr connect( std::shared_ptr const & e, std::weak_ptr const & r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } template - weak_ptr connect( shared_ptr const & e, shared_ptr const & r, F f ) + std::weak_ptr connect( std::shared_ptr const & e, std::shared_ptr const & r, F f ) { return synapse_detail::bind_front::signature>::pconnect_fwd(e,r,f); } } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/connection.hpp b/include/boost/synapse/connection.hpp index 903d219..eb7a0c2 100644 --- a/include/boost/synapse/connection.hpp +++ b/include/boost/synapse/connection.hpp @@ -16,7 +16,6 @@ # endif #endif -#include #include #include @@ -27,7 +26,7 @@ namespace boost { namespace synapse { virtual synapse_detail::weak_store const & emitter_() const=0; virtual synapse_detail::weak_store const & receiver_() const=0; - shared_ptr user_data_; + std::shared_ptr user_data_; protected: @@ -38,8 +37,8 @@ namespace boost { namespace synapse { template void set_user_data( T const & ); template T * get_user_data() const; - template shared_ptr emitter() const; - template shared_ptr receiver() const; + template std::shared_ptr emitter() const; + template std::shared_ptr receiver() const; }; class pconnection: @@ -82,16 +81,16 @@ namespace boost { namespace synapse { }; template - typename std::enable_if::value>::type set_user_data_( shared_ptr & ud, T const & x ) + typename std::enable_if::value>::type set_user_data_( std::shared_ptr & ud, T const & x ) { - if( deleter_user_data * d = get_deleter >(ud) ) + if( deleter_user_data * d = std::get_deleter >(ud) ) d->value = x; else ud.reset((void *)0, deleter_user_data(x)); } template - typename std::enable_if::value>::type set_user_data_( shared_ptr & ud, T const & x ) + typename std::enable_if::value>::type set_user_data_( std::shared_ptr & ud, T const & x ) { ud.reset((void *)0, deleter_user_data(x)); } @@ -106,18 +105,18 @@ namespace boost { namespace synapse { template T * connection::get_user_data() const { - synapse_detail::deleter_user_data * d = get_deleter >(user_data_); + synapse_detail::deleter_user_data * d = std::get_deleter >(user_data_); return d ? &d->value : 0; } template - shared_ptr connection::emitter() const + std::shared_ptr connection::emitter() const { return emitter_().maybe_lock(); } template - shared_ptr connection::receiver() const + std::shared_ptr connection::receiver() const { return receiver_().maybe_lock(); @@ -125,4 +124,8 @@ namespace boost { namespace synapse { } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/detail/common.hpp b/include/boost/synapse/detail/common.hpp index a111e58..58955d1 100644 --- a/include/boost/synapse/detail/common.hpp +++ b/include/boost/synapse/detail/common.hpp @@ -17,8 +17,8 @@ #endif #include -#include #include +#include #include namespace boost { namespace synapse { @@ -53,7 +53,7 @@ namespace boost { namespace synapse { public: - virtual void notify_connection_list_created( shared_ptr const & )=0; + virtual void notify_connection_list_created( std::shared_ptr const & )=0; virtual int emit( thread_local_signal_data const &, void const *, args_binder_base const * )=0; }; @@ -71,18 +71,18 @@ namespace boost { namespace synapse { class connection_list; friend class connection_list; - weak_ptr cl_; + std::weak_ptr cl_; class blocked_emitters_list; - weak_ptr bl_; + std::weak_ptr bl_; class posted_signals; - shared_ptr ps_; + std::shared_ptr ps_; - shared_ptr keep_meta_connected_tlsd_afloat_; - shared_ptr keep_meta_blocked_tlsd_afloat_; + std::shared_ptr keep_meta_connected_tlsd_afloat_; + std::shared_ptr keep_meta_blocked_tlsd_afloat_; - shared_ptr const & (* const get_cll_)( shared_ptr (*)() ); + std::shared_ptr const & (* const get_cll_)( std::shared_ptr (*)() ); std::atomic * const interthread_; thread_local_signal_data(): @@ -95,7 +95,7 @@ namespace boost { namespace synapse { { } - thread_local_signal_data( shared_ptr const & (*get_cll)( shared_ptr (*)() ), std::atomic & cl_count, std::atomic & interthread ): + thread_local_signal_data( std::shared_ptr const & (*get_cll)( std::shared_ptr (*)() ), std::atomic & cl_count, std::atomic & interthread ): cleanup_(&cleanup_stub), cl_count_(&cl_count), emit_(&emit_stub), @@ -124,19 +124,19 @@ namespace boost { namespace synapse { }; template - shared_ptr const & get_connection_list_list( shared_ptr (*create_connection_list_list)() ) + std::shared_ptr const & get_connection_list_list( std::shared_ptr (*create_connection_list_list)() ) { - static shared_ptr obj(create_connection_list_list()); + static std::shared_ptr obj(create_connection_list_list()); return obj; } template - shared_ptr const & get_thread_local_signal_data( bool allocate ); + std::shared_ptr const & get_thread_local_signal_data( bool allocate ); template struct register_with_non_meta { - static void keep_afloat( shared_ptr const & ) + static void keep_afloat( std::shared_ptr const & ) { } }; @@ -144,7 +144,7 @@ namespace boost { namespace synapse { template struct register_with_non_meta > { - static void keep_afloat( shared_ptr const & meta ) + static void keep_afloat( std::shared_ptr const & meta ) { auto main_tlsd = get_thread_local_signal_data(true); BOOST_SYNAPSE_ASSERT(!main_tlsd->keep_meta_connected_tlsd_afloat_); @@ -155,7 +155,7 @@ namespace boost { namespace synapse { template struct register_with_non_meta > { - static void keep_afloat( shared_ptr const & meta ) + static void keep_afloat( std::shared_ptr const & meta ) { auto main_tlsd = get_thread_local_signal_data(true); BOOST_SYNAPSE_ASSERT(!main_tlsd->keep_meta_blocked_tlsd_afloat_); @@ -169,14 +169,14 @@ namespace boost { namespace synapse { template struct thread_local_signal_data_ { - static shared_ptr const & get( bool allocate ) + static std::shared_ptr const & get( bool allocate ) { static std::atomic count; static std::atomic interthread; - static thread_local shared_ptr obj; + static thread_local std::shared_ptr obj; if( !obj && (allocate || interthread.load()) ) { - obj=synapse::make_shared(&get_connection_list_list,count,interthread); + obj=std::make_shared(&get_connection_list_list,count,interthread); register_with_non_meta::keep_afloat(obj); } return obj; @@ -186,12 +186,12 @@ namespace boost { namespace synapse { template struct thread_local_signal_data_ { - static shared_ptr const & get( bool allocate ) + static std::shared_ptr const & get( bool allocate ) { - static thread_local shared_ptr obj; + static thread_local std::shared_ptr obj; if( !obj && allocate ) { - obj=synapse::make_shared(); + obj=std::make_shared(); register_with_non_meta::keep_afloat(obj); } return obj; @@ -199,7 +199,7 @@ namespace boost { namespace synapse { }; template - shared_ptr const & get_thread_local_signal_data( bool allocate ) + std::shared_ptr const & get_thread_local_signal_data( bool allocate ) { return thread_local_signal_data_::get(allocate); } @@ -208,4 +208,8 @@ namespace boost { namespace synapse { } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/detail/config.hpp b/include/boost/synapse/detail/config.hpp index 44178b3..ce7fdb4 100644 --- a/include/boost/synapse/detail/config.hpp +++ b/include/boost/synapse/detail/config.hpp @@ -143,4 +143,8 @@ # endif #endif +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/detail/functional.hpp b/include/boost/synapse/detail/functional.hpp deleted file mode 100644 index f1f7bbd..0000000 --- a/include/boost/synapse/detail/functional.hpp +++ /dev/null @@ -1,45 +0,0 @@ -#ifndef BOOST_SYNAPSE_DEP_FUNCTIONAL_HPP_INCLUDED -#define BOOST_SYNAPSE_DEP_FUNCTIONAL_HPP_INCLUDED - -// Copyright (c) 2015-2020 Emil Dotchevski and Reverge Studios, Inc. - -// 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) - -#ifndef BOOST_SYNAPSE_ENABLE_WARNINGS -# if defined(__clang__) -# pragma clang system_header -# elif (__GNUC__*100+__GNUC_MINOR__>301) -# pragma GCC system_header -# elif defined(_MSC_VER) -# pragma warning(push,1) -# endif -#endif - -#ifdef BOOST_SYNAPSE_USE_BOOST - -#include - -namespace boost { namespace synapse { - - using boost::function; - using boost::ref; - using boost::cref; - -} } - -#else - -#include - -namespace boost { namespace synapse { - - using std::function; - using std::ref; - using std::cref; - -} } - -#endif - -#endif diff --git a/include/boost/synapse/detail/mp11.hpp b/include/boost/synapse/detail/mp11.hpp index 1b511b8..ebb4c0c 100644 --- a/include/boost/synapse/detail/mp11.hpp +++ b/include/boost/synapse/detail/mp11.hpp @@ -140,4 +140,8 @@ BOOST_SYNAPSE_CONSTEXPR auto tuple_apply( F && f, Tp && tp ) } } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/detail/smart_ptr.hpp b/include/boost/synapse/detail/smart_ptr.hpp deleted file mode 100644 index 09f7714..0000000 --- a/include/boost/synapse/detail/smart_ptr.hpp +++ /dev/null @@ -1,49 +0,0 @@ -#ifndef BOOST_SYNAPSE_DEP_SMART_PTR_HPP_INCLUDED -#define BOOST_SYNAPSE_DEP_SMART_PTR_HPP_INCLUDED - -// Copyright (c) 2015-2020 Emil Dotchevski and Reverge Studios, Inc. - -// 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) - -#ifndef BOOST_SYNAPSE_ENABLE_WARNINGS -# if defined(__clang__) -# pragma clang system_header -# elif (__GNUC__*100+__GNUC_MINOR__>301) -# pragma GCC system_header -# elif defined(_MSC_VER) -# pragma warning(push,1) -# endif -#endif - -#ifdef BOOST_SYNAPSE_USE_BOOST - -#include -#include -#include - -namespace boost { namespace synapse { - - using boost::shared_ptr; - using boost::weak_ptr; - using boost::make_shared; - using boost::get_deleter; - -} } - -#else - -#include - -namespace boost { namespace synapse { - - using std::shared_ptr; - using std::weak_ptr; - using std::make_shared; - using std::get_deleter; - -} } - -#endif - -#endif diff --git a/include/boost/synapse/detail/weak_store.hpp b/include/boost/synapse/detail/weak_store.hpp index 723337f..ba1ba1f 100644 --- a/include/boost/synapse/detail/weak_store.hpp +++ b/include/boost/synapse/detail/weak_store.hpp @@ -17,7 +17,7 @@ #endif #include -#include +#include namespace boost { namespace synapse { @@ -25,7 +25,7 @@ namespace boost { namespace synapse { { class weak_store { - weak_ptr w_; + std::weak_ptr w_; void const * px_; void (*type_)(); void (*ctype_)(); @@ -68,7 +68,7 @@ namespace boost { namespace synapse { } template - weak_store( weak_ptr const & w ): + weak_store( std::weak_ptr const & w ): w_(w), px_(0), type_(&type), @@ -80,7 +80,7 @@ namespace boost { namespace synapse { } template - weak_store( weak_ptr const & w ): + weak_store( std::weak_ptr const & w ): w_(w), px_(0), type_(0), @@ -92,7 +92,7 @@ namespace boost { namespace synapse { } template - weak_store( shared_ptr const & w ): + weak_store( std::shared_ptr const & w ): w_(w), px_(0), type_(&type), @@ -104,7 +104,7 @@ namespace boost { namespace synapse { } template - weak_store( shared_ptr const & w ): + weak_store( std::shared_ptr const & w ): w_(w), px_(0), type_(0), @@ -139,7 +139,7 @@ namespace boost { namespace synapse { } template - shared_ptr maybe_lock() const + std::shared_ptr maybe_lock() const { return access::get(maybe_lock(), &type, type_,ctype_); } @@ -148,37 +148,41 @@ namespace boost { namespace synapse { template struct weak_store:: access { - static shared_ptr get( shared_ptr const & p, void (*pt)(), void (*type)(), void (*)() ) + static std::shared_ptr get( std::shared_ptr const & p, void (*pt)(), void (*type)(), void (*)() ) { - return p && type==pt ? shared_ptr(p,(T *)p.get()) : shared_ptr(); + return p && type==pt ? std::shared_ptr(p,(T *)p.get()) : std::shared_ptr(); } }; template struct weak_store::access { - static shared_ptr get( shared_ptr const & p, void (*pt)(), void (*)(), void (*ctype)() ) + static std::shared_ptr get( std::shared_ptr const & p, void (*pt)(), void (*)(), void (*ctype)() ) { - return p && ctype==pt ? shared_ptr(p,(T const *)p.get()) : shared_ptr(); + return p && ctype==pt ? std::shared_ptr(p,(T const *)p.get()) : std::shared_ptr(); } }; template <> struct weak_store::access { - static shared_ptr get( shared_ptr const & p, void (*)(), void (*type)(), void (*)() ) + static std::shared_ptr get( std::shared_ptr const & p, void (*)(), void (*type)(), void (*)() ) { - return p && type ? shared_ptr(p,(void *)p.get()) : shared_ptr(); + return p && type ? std::shared_ptr(p,(void *)p.get()) : std::shared_ptr(); } }; template <> - inline shared_ptr weak_store::maybe_lock() const + inline std::shared_ptr weak_store::maybe_lock() const { - return px_ ? shared_ptr(shared_ptr(), px_) : w_.lock(); + return px_ ? std::shared_ptr(std::shared_ptr(), px_) : w_.lock(); } } } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/emit.hpp b/include/boost/synapse/emit.hpp index b8d30e0..07cb2e5 100644 --- a/include/boost/synapse/emit.hpp +++ b/include/boost/synapse/emit.hpp @@ -18,7 +18,7 @@ #include #include -#include +#include #include namespace boost { namespace synapse { @@ -41,7 +41,7 @@ namespace boost { namespace synapse { { public: - virtual shared_ptr clone() const = 0; + virtual std::shared_ptr clone() const = 0; virtual void call( void const * ) const = 0; virtual int call_translated( void const * ) const = 0; }; @@ -55,19 +55,19 @@ namespace boost { namespace synapse { { std::tuple a_; - shared_ptr clone() const final override + std::shared_ptr clone() const final override { - return synapse::make_shared(*this); + return std::make_shared(*this); } void call( void const * f ) const final override { - synapse_detail_mp11::tuple_apply(*static_cast const *>(f), a_); + synapse_detail_mp11::tuple_apply(*static_cast const *>(f), a_); } int call_translated( void const * f ) const final override { - return synapse_detail_mp11::tuple_apply(*static_cast const *>(f), a_); + return synapse_detail_mp11::tuple_apply(*static_cast const *>(f), a_); } public: @@ -78,24 +78,24 @@ namespace boost { namespace synapse { } }; - shared_ptr & meta_emitter(); + std::shared_ptr & meta_emitter(); template int emit_meta_connected( connection & c, unsigned connect_flags ) { - return emit >(meta_emitter().get(), ref(c), connect_flags); + return emit >(meta_emitter().get(), std::ref(c), connect_flags); } template int emit_meta_blocked( blocker & eb, bool is_blocked ) { - return emit >(meta_emitter().get(), ref(eb), is_blocked); + return emit >(meta_emitter().get(), std::ref(eb), is_blocked); } template int emit_fwd( void const * e, args_binder_base const & args ) { - if( shared_ptr const & tlsd = get_thread_local_signal_data(false) ) + if( std::shared_ptr const & tlsd = get_thread_local_signal_data(false) ) if( e ) return tlsd->emit_(*tlsd, e, &args); return 0; @@ -104,7 +104,7 @@ namespace boost { namespace synapse { template int emit_fwd_no_args( void const * e ) { - if( shared_ptr const & tlsd = get_thread_local_signal_data(false) ) + if( std::shared_ptr const & tlsd = get_thread_local_signal_data(false) ) if( e ) return tlsd->emit_(*tlsd, e, 0); return 0; @@ -119,4 +119,8 @@ namespace boost { namespace synapse { } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/properties.hpp b/include/boost/synapse/properties.hpp index fc46516..0b68b1c 100644 --- a/include/boost/synapse/properties.hpp +++ b/include/boost/synapse/properties.hpp @@ -29,13 +29,13 @@ namespace boost { namespace synapse { }; template - shared_ptr set_( ObjectRef const & o, Object * op, typename Property::type x ) + std::shared_ptr set_( ObjectRef const & o, Object * op, typename Property::type x ) { BOOST_SYNAPSE_ASSERT(op != 0); if( int n=emit >(op, &x, true) ) { BOOST_SYNAPSE_ASSERT(n == 1); - return shared_ptr(); + return std::shared_ptr(); } else return connect >(o, @@ -49,13 +49,13 @@ namespace boost { namespace synapse { } template - weak_ptr pset_( ObjectRef const & o, Object * op, typename Property::type x ) + std::weak_ptr pset_( ObjectRef const & o, Object * op, typename Property::type x ) { BOOST_SYNAPSE_ASSERT(op!=0); if( int n = emit >(op, &x, true) ) { BOOST_SYNAPSE_ASSERT(n == 1); - return weak_ptr(); + return std::weak_ptr(); } else return connect >(o, @@ -83,24 +83,24 @@ namespace boost { namespace synapse { }; template - shared_ptr set( Object * o, typename Property::type const & x ) + std::shared_ptr set( Object * o, typename Property::type const & x ) { return synapse_detail::set_(o, o, x); } template - weak_ptr set( shared_ptr const & o, typename Property::type x ) + std::weak_ptr set( std::shared_ptr const & o, typename Property::type x ) { return synapse_detail::pset_(o, o.get(), x); } template - weak_ptr set( weak_ptr const & o, typename Property::type x ) + std::weak_ptr set( std::weak_ptr const & o, typename Property::type x ) { - if( shared_ptr so = o.lock() ) + if( std::shared_ptr so = o.lock() ) return set(o, x); else - return weak_ptr(); + return std::weak_ptr(); } template @@ -114,4 +114,8 @@ namespace boost { namespace synapse { } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/signal_traits.hpp b/include/boost/synapse/signal_traits.hpp index 6c3b240..619a667 100644 --- a/include/boost/synapse/signal_traits.hpp +++ b/include/boost/synapse/signal_traits.hpp @@ -48,4 +48,8 @@ namespace boost { namespace synapse { } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/thread_local_queue.hpp b/include/boost/synapse/thread_local_queue.hpp index a90a247..80a5079 100644 --- a/include/boost/synapse/thread_local_queue.hpp +++ b/include/boost/synapse/thread_local_queue.hpp @@ -16,18 +16,22 @@ # endif #endif -#include -#include +#include +#include namespace boost { namespace synapse { struct thread_local_queue; - shared_ptr create_thread_local_queue(); + std::shared_ptr create_thread_local_queue(); int poll( thread_local_queue & ); int wait( thread_local_queue & ); - void post( thread_local_queue &, function const & ); + void post( thread_local_queue &, std::function const & ); } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/include/boost/synapse/translate.hpp b/include/boost/synapse/translate.hpp index edcc5e9..4bada33 100644 --- a/include/boost/synapse/translate.hpp +++ b/include/boost/synapse/translate.hpp @@ -21,31 +21,31 @@ namespace boost { namespace synapse { template - shared_ptr translate( OriginalEmitter *, TranslatedEmitter * ); + std::shared_ptr translate( OriginalEmitter *, TranslatedEmitter * ); template - weak_ptr translate( OriginalEmitter *, weak_ptr const & ); + std::weak_ptr translate( OriginalEmitter *, std::weak_ptr const & ); template - weak_ptr translate( OriginalEmitter *, shared_ptr const & ); + std::weak_ptr translate( OriginalEmitter *, std::shared_ptr const & ); template - weak_ptr translate( weak_ptr const &, TranslatedEmitter * ); + std::weak_ptr translate( std::weak_ptr const &, TranslatedEmitter * ); template - weak_ptr translate( weak_ptr const &, weak_ptr const & ); + std::weak_ptr translate( std::weak_ptr const &, std::weak_ptr const & ); template - weak_ptr translate( weak_ptr const &, shared_ptr const & ); + std::weak_ptr translate( std::weak_ptr const &, std::shared_ptr const & ); template - weak_ptr translate( shared_ptr const &, TranslatedEmitter * ); + std::weak_ptr translate( std::shared_ptr const &, TranslatedEmitter * ); template - weak_ptr translate( shared_ptr const &, weak_ptr const & ); + std::weak_ptr translate( std::shared_ptr const &, std::weak_ptr const & ); template - weak_ptr translate( shared_ptr const &, shared_ptr const & ); + std::weak_ptr translate( std::shared_ptr const &, std::shared_ptr const & ); } } @@ -64,7 +64,7 @@ namespace boost { namespace synapse { struct translate_binder { - typedef function function_type; + typedef std::function function_type; static function_type bind_emit( weak_store r ) { return @@ -75,88 +75,92 @@ namespace boost { namespace synapse { } }; - shared_ptr connect_translated_( shared_ptr const &, weak_store && e, weak_store && r, shared_ptr const &, int(*emit_meta_connected)(connection &,unsigned) ); - shared_ptr pconnect_translated_( shared_ptr const &, weak_store && e, weak_store && r, shared_ptr const &, int(*emit_meta_connected)(connection &,unsigned) ); + std::shared_ptr connect_translated_( std::shared_ptr const &, weak_store && e, weak_store && r, std::shared_ptr const &, int(*emit_meta_connected)(connection &,unsigned) ); + std::shared_ptr pconnect_translated_( std::shared_ptr const &, weak_store && e, weak_store && r, std::shared_ptr const &, int(*emit_meta_connected)(connection &,unsigned) ); template - shared_ptr translate_fwd( weak_store && e, weak_store && r ) + std::shared_ptr translate_fwd( weak_store && e, weak_store && r ) { typedef translate_binder translator; return connect_translated_( get_thread_local_signal_data(true), std::move(e), std::move(r), - synapse::make_shared(translator::bind_emit(r)), + std::make_shared(translator::bind_emit(r)), &emit_meta_connected); } template - shared_ptr ptranslate_fwd( weak_store && e, weak_store && r ) + std::shared_ptr ptranslate_fwd( weak_store && e, weak_store && r ) { typedef translate_binder translator; return pconnect_translated_( get_thread_local_signal_data(true), std::move(e), std::move(r), - synapse::make_shared(translator::bind_emit(r)), + std::make_shared(translator::bind_emit(r)), &emit_meta_connected); } } template - shared_ptr translate( OriginalEmitter * oe, TranslatedEmitter * te ) + std::shared_ptr translate( OriginalEmitter * oe, TranslatedEmitter * te ) { return synapse_detail::translate_fwd(oe, te); } template - weak_ptr translate( OriginalEmitter * oe, weak_ptr const & te ) + std::weak_ptr translate( OriginalEmitter * oe, std::weak_ptr const & te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( OriginalEmitter * oe, shared_ptr const & te ) + std::weak_ptr translate( OriginalEmitter * oe, std::shared_ptr const & te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( weak_ptr const & oe, TranslatedEmitter * te ) + std::weak_ptr translate( std::weak_ptr const & oe, TranslatedEmitter * te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( weak_ptr const & oe, weak_ptr const & te ) + std::weak_ptr translate( std::weak_ptr const & oe, std::weak_ptr const & te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( weak_ptr const & oe, shared_ptr const & te ) + std::weak_ptr translate( std::weak_ptr const & oe, std::shared_ptr const & te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( shared_ptr const & oe, TranslatedEmitter * te ) + std::weak_ptr translate( std::shared_ptr const & oe, TranslatedEmitter * te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( shared_ptr const & oe, weak_ptr const & te ) + std::weak_ptr translate( std::shared_ptr const & oe, std::weak_ptr const & te ) { return synapse_detail::ptranslate_fwd(oe, te); } template - weak_ptr translate( shared_ptr const & oe, shared_ptr const & te ) + std::weak_ptr translate( std::shared_ptr const & oe, std::shared_ptr const & te ) { return synapse_detail::ptranslate_fwd(oe, te); } } } +#if defined(_MSC_VER) && !defined(BOOST_SYNAPSE_ENABLE_WARNINGS) +# pragma warning(pop) +#endif + #endif diff --git a/meson.build b/meson.build index f8b4776..fe5ef9b 100644 --- a/meson.build +++ b/meson.build @@ -46,7 +46,6 @@ defines = [ ] dep_boost = [ ] if get_option('synapse_use_boost') # Requires that Synapse resides under boost_root/libs/synapse. dep_boost = declare_dependency(include_directories: '../..') - defines = [ '-DBOOST_SYNAPSE_USE_BOOST' ] endif if not option_suppress_warnings defines = [ '-DBOOST_SYNAPSE_ENABLE_WARNINGS' ] diff --git a/src/block.cpp b/src/block.cpp index f9c3a74..a45a008 100644 --- a/src/block.cpp +++ b/src/block.cpp @@ -19,7 +19,7 @@ namespace boost { namespace synapse { { blocker_impl( blocker_impl const & ); blocker_impl & operator=( blocker_impl const & ); - shared_ptr const bl_; + std::shared_ptr const bl_; weak_store const & emitter_() const final override { @@ -29,7 +29,7 @@ namespace boost { namespace synapse { public: weak_store e_; - blocker_impl( weak_store &&, shared_ptr const & ); + blocker_impl( weak_store &&, std::shared_ptr const & ); ~blocker_impl(); }; } //namespace @@ -42,10 +42,10 @@ namespace boost { namespace synapse { struct bl_rec { void const * ep_; - weak_ptr eb_; + std::weak_ptr eb_; blocker_impl const * ebp_; - bl_rec( void const * ep, shared_ptr const & eb ): + bl_rec( void const * ep, std::shared_ptr const & eb ): ep_(ep), eb_(eb), ebp_(eb.get()) @@ -75,7 +75,7 @@ namespace boost { namespace synapse { static bool emitter_blocked_impl( thread_local_signal_data const & tlsd, void const * e ) { - if( shared_ptr bl=tlsd.bl_.lock() ) + if( std::shared_ptr bl=tlsd.bl_.lock() ) return bl->is_blocked(e); else { @@ -84,14 +84,14 @@ namespace boost { namespace synapse { } } - shared_ptr const tlsd_; + std::shared_ptr const tlsd_; std::vector bl_; public: int (* const emit_meta_blocked_)(blocker &,bool); - blocked_emitters_list( shared_ptr const & tlsd, int (*emit_meta_blocked)(blocker &,bool) ): + blocked_emitters_list( std::shared_ptr const & tlsd, int (*emit_meta_blocked)(blocker &,bool) ): tlsd_(tlsd), emit_meta_blocked_(emit_meta_blocked) { @@ -105,7 +105,7 @@ namespace boost { namespace synapse { tlsd_->emitter_blocked_=&emitter_blocked_stub; } - shared_ptr block( shared_ptr const & bl, weak_store && e, shared_ptr const & sp ) + std::shared_ptr block( std::shared_ptr const & bl, weak_store && e, std::shared_ptr const & sp ) { BOOST_SYNAPSE_ASSERT(bl); BOOST_SYNAPSE_ASSERT(sp); @@ -113,13 +113,13 @@ namespace boost { namespace synapse { std::vector::const_iterator i=std::find_if(bl_.begin(),bl_.end(),[&sp](bl_rec const & r) { return r.same_emitter(sp.get()); }); if( i!=bl_.end() ) { - shared_ptr bb=i->eb_.lock(); + std::shared_ptr bb=i->eb_.lock(); BOOST_SYNAPSE_ASSERT(bb); return bb; } else { - shared_ptr bb=make_shared(std::move(e),bl); + std::shared_ptr bb=std::make_shared(std::move(e),bl); bl_.push_back(bl_rec(sp.get(),bb)); return bb; } @@ -141,7 +141,7 @@ namespace boost { namespace synapse { namespace { - blocker_impl::blocker_impl( weak_store && e, shared_ptr const & bl ): + blocker_impl::blocker_impl( weak_store && e, std::shared_ptr const & bl ): bl_(bl), e_(std::move(e)) { @@ -157,27 +157,27 @@ namespace boost { namespace synapse { bl_->emit_meta_blocked_(*this,false); } - shared_ptr get_blocked_list_( shared_ptr const & tlsd, int (*emit_meta_blocked)(blocker &,bool) ) + std::shared_ptr get_blocked_list_( std::shared_ptr const & tlsd, int (*emit_meta_blocked)(blocker &,bool) ) { - shared_ptr bl=tlsd->bl_.lock(); + std::shared_ptr bl=tlsd->bl_.lock(); if( !bl ) { - make_shared(tlsd,emit_meta_blocked).swap(bl); + std::make_shared(tlsd,emit_meta_blocked).swap(bl); tlsd->bl_=bl; } return bl; } } //namespace - shared_ptr block_( shared_ptr const & tlsd, weak_store && e, int(*emit_meta_blocked)(blocker &,bool) ) + std::shared_ptr block_( std::shared_ptr const & tlsd, weak_store && e, int(*emit_meta_blocked)(blocker &,bool) ) { - if( shared_ptr sp=e.maybe_lock() ) + if( std::shared_ptr sp=e.maybe_lock() ) { - shared_ptr bl=get_blocked_list_(tlsd,emit_meta_blocked); + std::shared_ptr bl=get_blocked_list_(tlsd,emit_meta_blocked); return bl->block(bl,std::move(e),sp); } else - return shared_ptr(); + return std::shared_ptr(); } } diff --git a/src/connect.cpp b/src/connect.cpp index bccc18c..1e264f4 100644 --- a/src/connect.cpp +++ b/src/connect.cpp @@ -31,14 +31,14 @@ namespace boost { namespace synapse { void const * ep_; weak_store e_; weak_store r_; - shared_ptr fn_; - shared_ptr c_; + std::shared_ptr fn_; + std::shared_ptr c_; int next_; bool translated_; public: - conn_rec( weak_store && e, weak_store && r, shared_ptr const & fn, shared_ptr const & c, bool translated ): + conn_rec( weak_store && e, weak_store && r, std::shared_ptr const & fn, std::shared_ptr const & c, bool translated ): ep_(e.maybe_lock().get()), e_(std::move(e)), r_(std::move(r)), @@ -51,9 +51,9 @@ namespace boost { namespace synapse { BOOST_SYNAPSE_ASSERT(fn); } - shared_ptr release() + std::shared_ptr release() { - shared_ptr c; c.swap(c_); + std::shared_ptr c; c.swap(c_); return c; } @@ -123,13 +123,13 @@ namespace boost { namespace synapse { if( args ) return args->call_translated(fn_.get()); else - return (*static_cast const *>(fn_.get()))(); + return (*static_cast const *>(fn_.get()))(); else { if( args ) args->call(fn_.get()); else - (*static_cast const *>(fn_.get()))(); + (*static_cast const *>(fn_.get()))(); return 1; } return 0; @@ -142,7 +142,7 @@ namespace boost { namespace synapse { connection_list( connection_list const & ); connection_list & operator=( connection_list const & ); - weak_ptr const tlsd_; + std::weak_ptr const tlsd_; std::vector conn_; std::vector * emit_conn_ptr_; int first_free_; @@ -197,7 +197,7 @@ namespace boost { namespace synapse { if( interthread_interface * interthread=tlsd.interthread_->load() ) n1=interthread->emit(tlsd,e,args); if( !tlsd.emitter_blocked_(tlsd,e) ) - if( shared_ptr cl=tlsd.cl_.lock() ) + if( std::shared_ptr cl=tlsd.cl_.lock() ) { int n2=cl->emit_from_emitter(e,args); return n1+n2; @@ -209,7 +209,7 @@ namespace boost { namespace synapse { static void cleanup_impl( thread_local_signal_data const & tlsd ) { - shared_ptr cl=tlsd.cl_.lock(); + std::shared_ptr cl=tlsd.cl_.lock(); BOOST_SYNAPSE_ASSERT(cl); cl->cleanup(); cl->destroy(); @@ -217,7 +217,7 @@ namespace boost { namespace synapse { void destroy() { - if( shared_ptr tlsd=tlsd_.lock() ) + if( std::shared_ptr tlsd=tlsd_.lock() ) { BOOST_SYNAPSE_ASSERT(tlsd); if( tlsd->cl_count_ ) @@ -240,7 +240,7 @@ namespace boost { namespace synapse { int (* const emit_meta_connected_)( connection &, unsigned ); - connection_list( shared_ptr const & tlsd, int (*emit_meta_connected)( connection &, unsigned ) ): + connection_list( std::shared_ptr const & tlsd, int (*emit_meta_connected)( connection &, unsigned ) ): tlsd_(tlsd), emit_conn_ptr_(0), first_free_(-1), @@ -275,7 +275,7 @@ namespace boost { namespace synapse { return conn_[index].receiver(); } - shared_ptr release( int index ) + std::shared_ptr release( int index ) { return conn_[index].release(); } @@ -371,13 +371,13 @@ namespace boost { namespace synapse { void purge() { check_invariants(); - std::deque > purged; + std::deque > purged; for( int const * i=&first_rec_; *i!=-1; ) { conn_rec & cr=conn_[*i]; BOOST_SYNAPSE_ASSERT(!cr.is_free()); if( cr.expired() ) - if( shared_ptr c=cr.release() ) + if( std::shared_ptr c=cr.release() ) purged.push_back(c); i=&cr.next(); } @@ -390,12 +390,12 @@ namespace boost { namespace synapse { try #endif { - std::deque > purged; + std::deque > purged; for( int const * i=&first_rec_; *i!=-1; ) { conn_rec & cr=conn_[*i]; BOOST_SYNAPSE_ASSERT(!cr.is_free()); - if( shared_ptr c=cr.release() ) + if( std::shared_ptr c=cr.release() ) purged.push_back(c); i=&cr.next(); } @@ -415,13 +415,13 @@ namespace boost { namespace synapse { namespace { - shared_ptr - get_connection_list_( shared_ptr const & tlsd, int (*emit_meta_connected)(connection &,unsigned) ) + std::shared_ptr + get_connection_list_( std::shared_ptr const & tlsd, int (*emit_meta_connected)(connection &,unsigned) ) { - shared_ptr cl=tlsd->cl_.lock(); + std::shared_ptr cl=tlsd->cl_.lock(); if( !cl ) { - make_shared(tlsd,emit_meta_connected).swap(cl); + std::make_shared(tlsd,emit_meta_connected).swap(cl); tlsd->cl_=cl; if( tlsd->interthread_ ) if( interthread_interface * interthread=get_interthread_api() ) @@ -438,7 +438,7 @@ namespace boost { namespace synapse { { connection_impl( connection_impl const & ); connection_impl & operator=( connection_impl const & ); - shared_ptr const cl_; + std::shared_ptr const cl_; int position_; weak_store const & emitter_() const final override @@ -453,7 +453,7 @@ namespace boost { namespace synapse { public: - explicit connection_impl( shared_ptr const & cl ): + explicit connection_impl( std::shared_ptr const & cl ): cl_(cl) { } @@ -489,42 +489,42 @@ namespace boost { namespace synapse { cl_->remove(position_); } - shared_ptr release() const + std::shared_ptr release() const { - shared_ptr pc = cl_->release(position_); - return shared_ptr(pc,static_cast(this)); + std::shared_ptr pc = cl_->release(position_); + return std::shared_ptr(pc,static_cast(this)); } - shared_ptr release() + std::shared_ptr release() { - shared_ptr pc = cl_->release(position_); - return shared_ptr(pc,static_cast(this)); + std::shared_ptr pc = cl_->release(position_); + return std::shared_ptr(pc,static_cast(this)); } }; - shared_ptr connect_impl( shared_ptr const & tlsd, weak_store && e, weak_store && r, shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned), bool translated ) + std::shared_ptr connect_impl( std::shared_ptr const & tlsd, weak_store && e, weak_store && r, std::shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned), bool translated ) { BOOST_SYNAPSE_ASSERT(fn); - auto c=make_shared >(get_connection_list_(tlsd,emit_meta_connected)); + auto c=std::make_shared >(get_connection_list_(tlsd,emit_meta_connected)); c->connect( conn_rec( std::move(e), - r.empty() ? weak_store(weak_ptr >(c)) : std::move(r), + r.empty() ? weak_store(std::weak_ptr >(c)) : std::move(r), fn, - shared_ptr(), + std::shared_ptr(), translated ) ); return c; } - shared_ptr pconnect_impl( shared_ptr const & tlsd, weak_store && e, weak_store && r, shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned), bool translated ) + std::shared_ptr pconnect_impl( std::shared_ptr const & tlsd, weak_store && e, weak_store && r, std::shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned), bool translated ) { BOOST_SYNAPSE_ASSERT(fn); BOOST_SYNAPSE_ASSERT(e.lockable() || r.lockable()); - auto c=make_shared >(get_connection_list_(tlsd,emit_meta_connected)); + auto c=std::make_shared >(get_connection_list_(tlsd,emit_meta_connected)); c->connect( conn_rec( std::move(e), - r.empty() ? weak_store(weak_ptr >(c)) : std::move(r), + r.empty() ? weak_store(std::weak_ptr >(c)) : std::move(r), fn, c, translated ) ); @@ -532,36 +532,36 @@ namespace boost { namespace synapse { } } - shared_ptr connect_( shared_ptr const & tlsd, weak_store && e, weak_store && r, shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) + std::shared_ptr connect_( std::shared_ptr const & tlsd, weak_store && e, weak_store && r, std::shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) { return connect_impl(tlsd,std::move(e),std::move(r),fn,emit_meta_connected,false); } - shared_ptr pconnect_( shared_ptr const & tlsd, weak_store && e, weak_store && r, shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) + std::shared_ptr pconnect_( std::shared_ptr const & tlsd, weak_store && e, weak_store && r, std::shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) { return pconnect_impl(tlsd,std::move(e),std::move(r),fn,emit_meta_connected,false); } - shared_ptr connect_translated_( shared_ptr const & tlsd, weak_store && e, weak_store && r, shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) + std::shared_ptr connect_translated_( std::shared_ptr const & tlsd, weak_store && e, weak_store && r, std::shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) { return connect_impl(tlsd,std::move(e),std::move(r),fn,emit_meta_connected,true); } - shared_ptr pconnect_translated_( shared_ptr const & tlsd, weak_store && e, weak_store && r, shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) + std::shared_ptr pconnect_translated_( std::shared_ptr const & tlsd, weak_store && e, weak_store && r, std::shared_ptr const & fn, int(*emit_meta_connected)(connection &,unsigned) ) { return pconnect_impl(tlsd,std::move(e),std::move(r),fn,emit_meta_connected,true); } - shared_ptr & meta_emitter() + std::shared_ptr & meta_emitter() { - static shared_ptr me(make_shared(42)); + static std::shared_ptr me(std::make_shared(42)); return me; } } namespace meta { - weak_ptr emitter() + std::weak_ptr emitter() { return synapse_detail::meta_emitter(); } @@ -583,18 +583,18 @@ namespace boost { namespace synapse { { } - shared_ptr release( weak_ptr const & c ) + std::shared_ptr release( std::weak_ptr const & c ) { - shared_ptr sp = c.lock(); - shared_ptr released = static_cast const *>(sp.get())->release(); - return released ? released : shared_ptr(); + std::shared_ptr sp = c.lock(); + std::shared_ptr released = static_cast const *>(sp.get())->release(); + return released ? released : std::shared_ptr(); } - shared_ptr release( weak_ptr const & c ) + std::shared_ptr release( std::weak_ptr const & c ) { - shared_ptr sp = c.lock(); - shared_ptr released = static_cast *>(sp.get())->release(); - return released ? released : shared_ptr(); + std::shared_ptr sp = c.lock(); + std::shared_ptr released = static_cast *>(sp.get())->release(); + return released ? released : std::shared_ptr(); } } } diff --git a/src/thread_local_queue.cpp b/src/thread_local_queue.cpp index c975532..da333a8 100644 --- a/src/thread_local_queue.cpp +++ b/src/thread_local_queue.cpp @@ -28,11 +28,11 @@ namespace boost { namespace synapse { { unsigned serial_number; void const * e; - shared_ptr args; + std::shared_ptr args; posted() { } - posted( unsigned serial_number, void const * e, shared_ptr const & args ): + posted( unsigned serial_number, void const * e, std::shared_ptr const & args ): serial_number(serial_number), e(e), args(args) @@ -63,7 +63,7 @@ namespace boost { namespace synapse { return false; else { - shared_ptr a; + std::shared_ptr a; if( args ) a=args->clone(); { @@ -89,7 +89,7 @@ namespace boost { namespace synapse { } BOOST_SYNAPSE_ASSERT(p.e!=0); if( !tlsd.emitter_blocked_(tlsd,p.e) ) - if( shared_ptr cl=tlsd.cl_.lock() ) + if( std::shared_ptr cl=tlsd.cl_.lock() ) return emit_from_emitter(*cl,p.e,p.args.get()); return 0; } @@ -99,11 +99,11 @@ namespace boost { namespace synapse { { class cl_rec { - weak_ptr tlsd_; - weak_ptr cl_; + std::weak_ptr tlsd_; + std::weak_ptr cl_; public: - explicit cl_rec( shared_ptr const & tlsd ): + explicit cl_rec( std::shared_ptr const & tlsd ): tlsd_(tlsd), cl_(tlsd->cl_) { @@ -114,9 +114,9 @@ namespace boost { namespace synapse { return cl_.expired() || tlsd_.expired(); } - shared_ptr lock() const + std::shared_ptr lock() const { - return cl_.expired()? shared_ptr() : tlsd_.lock(); + return cl_.expired()? std::shared_ptr() : tlsd_.lock(); } }; @@ -141,7 +141,7 @@ namespace boost { namespace synapse { { } - void notify_connection_list_created( shared_ptr const & tlsd ) + void notify_connection_list_created( std::shared_ptr const & tlsd ) { std::lock_guard lk(mut_); same_signal_different_threads_.push_back(cl_rec(tlsd)); @@ -154,7 +154,7 @@ namespace boost { namespace synapse { int count=0; std::lock_guard lk(mut_); for( auto & r : same_signal_different_threads_ ) - if( shared_ptr sp=r.lock() ) + if( std::shared_ptr sp=r.lock() ) if( sp->ps_ ) count+=int(sp->ps_->post(e,args)); return count; @@ -163,9 +163,9 @@ namespace boost { namespace synapse { namespace { - shared_ptr create_connection_list_list() + std::shared_ptr create_connection_list_list() { - return make_shared(); + return std::make_shared(); } class thread_local_connection_list_list @@ -189,11 +189,11 @@ namespace boost { namespace synapse { { } - void notify_connection_list_created( shared_ptr const & tlsd ) + void notify_connection_list_created( std::shared_ptr const & tlsd ) { if( has_tlq_ ) { - shared_ptr ps=synapse::make_shared(emit_serial_number_,wait_cond_); + std::shared_ptr ps=std::make_shared(emit_serial_number_,wait_cond_); { std::lock_guard lk(tlsd->get_cll_(&create_connection_list_list)->mut_); tlsd->ps_.swap(ps); @@ -207,9 +207,9 @@ namespace boost { namespace synapse { { BOOST_SYNAPSE_ASSERT(!has_tlq_); for( auto & r : same_thread_different_signals_ ) - if( shared_ptr sp=r.lock() ) + if( std::shared_ptr sp=r.lock() ) { - shared_ptr ps=synapse::make_shared(emit_serial_number_,wait_cond_); + std::shared_ptr ps=std::make_shared(emit_serial_number_,wait_cond_); { std::lock_guard lk(sp->get_cll_(&create_connection_list_list)->mut_); sp->ps_.swap(ps); @@ -222,9 +222,9 @@ namespace boost { namespace synapse { { BOOST_SYNAPSE_ASSERT(has_tlq_); for( auto & r : same_thread_different_signals_ ) - if( shared_ptr sp = r.lock() ) + if( std::shared_ptr sp = r.lock() ) { - shared_ptr ps; + std::shared_ptr ps; { std::lock_guard lk(sp->get_cll_(&create_connection_list_list)->mut_); sp->ps_.swap(ps); @@ -245,7 +245,7 @@ namespace boost { namespace synapse { bool found = std::find_if( same_thread_different_signals_.begin(), same_thread_different_signals_.end(), [&count,serial_number]( cl_rec const & r ) { - if( shared_ptr sp=r.lock() ) + if( std::shared_ptr sp=r.lock() ) { int n=sp->ps_->emit_if_serial_number_matches(serial_number,*sp); if( n>=0 ) @@ -273,9 +273,9 @@ namespace boost { namespace synapse { } }; - shared_ptr get_thread_local_connection_list_list() + std::shared_ptr get_thread_local_connection_list_list() { - static thread_local shared_ptr tlcll(make_shared()); + static thread_local std::shared_ptr tlcll(std::make_shared()); return tlcll; } } @@ -285,7 +285,7 @@ namespace boost { namespace synapse { class interthread_impl: public interthread_interface { - void notify_connection_list_created( shared_ptr const & tlsd ) final override + void notify_connection_list_created( std::shared_ptr const & tlsd ) final override { tlsd->get_cll_(&create_connection_list_list)->notify_connection_list_created(tlsd); get_thread_local_connection_list_list()->notify_connection_list_created(tlsd); @@ -303,7 +303,7 @@ namespace boost { namespace synapse { namespace { - typedef struct bare_lambda_(*bare_lambda)( function const & ); + typedef struct bare_lambda_(*bare_lambda)( std::function const & ); } struct thread_local_queue @@ -313,7 +313,7 @@ namespace boost { namespace synapse { thread_local_queue & operator=( thread_local_queue const & ); std::thread::id const tid_; - shared_ptr const tlcll_; + std::shared_ptr const tlcll_; public: @@ -341,16 +341,16 @@ namespace boost { namespace synapse { return tlcll_->wait(); } - void post( function const & f ) + void post( std::function const & f ) { BOOST_SYNAPSE_ASSERT(f); emit(this,f); } }; - shared_ptr create_thread_local_queue() + std::shared_ptr create_thread_local_queue() { - std::shared_ptr tlq = make_shared(); + std::shared_ptr tlq = std::make_shared(); (void) connect(tlq, []( std::function const & f ) { BOOST_SYNAPSE_ASSERT(f); @@ -369,7 +369,7 @@ namespace boost { namespace synapse { return tlq.wait(); } - void post( thread_local_queue & tlq, function const & f ) + void post( thread_local_queue & tlq, std::function const & f ) { tlq.post(f); } diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 new file mode 100644 index 0000000..cad4397 --- /dev/null +++ b/test/Jamfile.v2 @@ -0,0 +1,49 @@ +# Copyright (c) 2015-2020 Emil Dotchevski and Reverge Studios, Inc. + +# 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) + +import testing ; +import path ; + +project + : requirements + 11 + static + gcc:"-Wno-dangling-else -Wno-sign_compare -w" + clang:"-Wno-delete-non-abstract-non-virtual-dtor -Wno-delete-non-virtual-dtor -Wno-dangling-else -w" + ; + +compile _hpp_compile_block_test.cpp ; +compile _hpp_compile_blocker_test.cpp ; +compile _hpp_compile_connect_test.cpp ; +compile _hpp_compile_connection_test.cpp ; +compile _hpp_compile_emit_test.cpp ; +compile _hpp_compile_thread_local_queue_test.cpp : multi ; +compile _hpp_compile_translate_test.cpp ; + +run args_connect_test.cpp ../build//synapse ; +run args_translate_test.cpp ../build//synapse ; +run block_emit_test.cpp ../build//synapse ; +run block_test.cpp ../build//block ; +run connect_emit_test.cpp ../build//synapse ; +run connection_lifetime_test.cpp ../build//synapse ; +run connection_user_data_test.cpp ../build//synapse ; +run ct_basic_test.cpp ../build//synapse : : : multi ; +run ct_lambda_test.cpp ../build//synapse : : : multi ; +run ct_tlq_lifetime_test.cpp ../build//synapse : : : multi ; +run ct_wait_test.cpp ../build//synapse : : : multi ; +run emit_stub_test.cpp ../build//emit ; +run emit_test.cpp ../build//synapse ; +run property_test.cpp ../build//synapse ; +run release_test.cpp ../build//synapse ; +run shutdown_test1.cpp ../build//synapse ; +run shutdown_test2.cpp ../build//synapse ; +run shutdown_test3.cpp ../build//synapse ; +run shutdown_test4.cpp ../build//synapse ; +run shutdown_test5.cpp ../build//synapse ; +run shutdown_test6.cpp ../build//synapse ; +run shutdown_test7.cpp ../build//synapse ; +run shutdown_test8.cpp ../build//synapse ; +run shutdown_test9.cpp ../build//synapse ; +run weak_store_test.cpp ; diff --git a/test/args_connect_test.cpp b/test/args_connect_test.cpp index 90ae73e..e8b1010 100644 --- a/test/args_connect_test.cpp +++ b/test/args_connect_test.cpp @@ -9,8 +9,6 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; namespace { @@ -27,7 +25,7 @@ namespace int connect_count=0; int count=0; my_emitter_type e1; - shared_ptr mc_c1 = release(synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release(synapse::connect >(synapse::meta::emitter(), [&e1,&connect_count]( synapse::connection & c, unsigned flags ) { if( flags&synapse::meta::connect_flags::connecting ) @@ -40,7 +38,7 @@ namespace } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c1=synapse::connect(&e1, + std::shared_ptr c1=synapse::connect(&e1, [&count]() { ++count; @@ -53,8 +51,8 @@ namespace c1.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -69,7 +67,7 @@ namespace int connect_count=0; int count=0; my_emitter_type e1; - shared_ptr mc_c1 = release(synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release(synapse::connect >(synapse::meta::emitter(), [&e1,&connect_count]( synapse::connection & c, unsigned flags ) { if( flags&synapse::meta::connect_flags::connecting ) @@ -82,7 +80,7 @@ namespace } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c1=synapse::connect(&e1, + std::shared_ptr c1=synapse::connect(&e1, [&count]( int a1 ) { BOOST_TEST_EQ(a1, 42); @@ -96,8 +94,8 @@ namespace c1.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -112,7 +110,7 @@ namespace int connect_count=0; int count=0; my_emitter_type e1; - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&e1,&connect_count]( synapse::connection & c, unsigned flags ) { if( flags&synapse::meta::connect_flags::connecting ) @@ -125,7 +123,7 @@ namespace } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c1=synapse::connect(&e1, + std::shared_ptr c1=synapse::connect(&e1, [&count]( int a1, float a2 ) { BOOST_TEST_EQ(a1, 42); @@ -140,8 +138,8 @@ namespace c1.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -156,7 +154,7 @@ namespace int connect_count=0; int count=0; my_emitter_type e1; - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&e1,&connect_count]( synapse::connection & c, unsigned flags ) { if( flags&synapse::meta::connect_flags::connecting ) @@ -169,7 +167,7 @@ namespace } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c1=synapse::connect(&e1, + std::shared_ptr c1=synapse::connect(&e1, [&count]( int a1, float a2, std::string const & a3 ) { BOOST_TEST_EQ(a1, 42); @@ -185,8 +183,8 @@ namespace c1.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -201,7 +199,7 @@ namespace int connect_count=0; int count=0; my_emitter_type e1; - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&e1,&connect_count]( synapse::connection & c, unsigned flags ) { if( flags&synapse::meta::connect_flags::connecting ) @@ -215,7 +213,7 @@ namespace BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); short a4=42; - shared_ptr c1=synapse::connect(&e1, + std::shared_ptr c1=synapse::connect(&e1, [&count,&a4]( int a1, float a2, std::string const & a3, short & a4_ ) { BOOST_TEST_EQ(a1, 42); @@ -225,15 +223,15 @@ namespace ++count; } ); BOOST_TEST_EQ(connect_count, 1); - BOOST_TEST_EQ(synapse::emit(&e1,42,42.42f,"42",synapse::ref(a4)), 0); + BOOST_TEST_EQ(synapse::emit(&e1,42,42.42f,"42",std::ref(a4)), 0); BOOST_TEST_EQ(count, 0); - BOOST_TEST_EQ(synapse::emit(&e1,42,42.42f,"42",synapse::ref(a4)), 1); + BOOST_TEST_EQ(synapse::emit(&e1,42,42.42f,"42",std::ref(a4)), 1); BOOST_TEST_EQ(count, 1); c1.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } diff --git a/test/args_translate_test.cpp b/test/args_translate_test.cpp index 9b6335a..71f8d44 100644 --- a/test/args_translate_test.cpp +++ b/test/args_translate_test.cpp @@ -12,8 +12,6 @@ # pragma warning( disable: 4244 ) // 'argument': conversion from '_Ty' to 'float', possible loss of data #endif namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; namespace { @@ -42,23 +40,23 @@ namespace int count=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c0.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e2]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e2,c,flags); } ) ); BOOST_TEST(mc_c2.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c0=synapse::translate(&e1,&e1); + std::shared_ptr c0=synapse::translate(&e1,&e1); BOOST_TEST_EQ(connect_count, 1); - shared_ptr c1=synapse::translate(&e1,&e2); + std::shared_ptr c1=synapse::translate(&e1,&e2); BOOST_TEST_EQ(connect_count, 2); - shared_ptr c2=synapse::connect(&e2, + std::shared_ptr c2=synapse::connect(&e2, [&count]() { ++count; @@ -81,20 +79,20 @@ namespace BOOST_TEST_EQ(count, 4); BOOST_TEST_EQ(connect_count, 2); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c1.reset(); BOOST_TEST_EQ(connect_count, 1); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c0.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -110,23 +108,23 @@ namespace int count=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c0.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e2]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e2,c,flags); } ) ); BOOST_TEST(mc_c2.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c0=synapse::translate(&e1,&e1); + std::shared_ptr c0=synapse::translate(&e1,&e1); BOOST_TEST_EQ(connect_count, 1); - shared_ptr c1=synapse::translate(&e1,&e2); + std::shared_ptr c1=synapse::translate(&e1,&e2); BOOST_TEST_EQ(connect_count, 2); - shared_ptr c2=synapse::connect(&e2, + std::shared_ptr c2=synapse::connect(&e2, [&count]( int a1 ) { BOOST_TEST_EQ(a1, 42); @@ -150,20 +148,20 @@ namespace BOOST_TEST_EQ(count, 4); BOOST_TEST_EQ(connect_count, 2); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c1.reset(); BOOST_TEST_EQ(connect_count, 1); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c0.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -178,23 +176,23 @@ namespace int count=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c0.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e2]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e2,c,flags); } ) ); BOOST_TEST(mc_c2.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c0=synapse::translate(&e1,&e1); + std::shared_ptr c0=synapse::translate(&e1,&e1); BOOST_TEST_EQ(connect_count, 1); - shared_ptr c1=synapse::translate(&e1,&e2); + std::shared_ptr c1=synapse::translate(&e1,&e2); BOOST_TEST_EQ(connect_count, 2); - shared_ptr c2=synapse::connect(&e2, + std::shared_ptr c2=synapse::connect(&e2, [&count]( int a1, float a2 ) { BOOST_TEST_EQ(a1, 42); @@ -219,20 +217,20 @@ namespace BOOST_TEST_EQ(count, 4); BOOST_TEST_EQ(connect_count, 2); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c1.reset(); BOOST_TEST_EQ(connect_count, 1); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c0.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -248,23 +246,23 @@ namespace int count=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c0.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e2]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e2,c,flags); } ) ); BOOST_TEST(mc_c2.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr c0=synapse::translate(&e1,&e1); + std::shared_ptr c0=synapse::translate(&e1,&e1); BOOST_TEST_EQ(connect_count, 1); - shared_ptr c1=synapse::translate(&e1,&e2); + std::shared_ptr c1=synapse::translate(&e1,&e2); BOOST_TEST_EQ(connect_count, 2); - shared_ptr c2=synapse::connect(&e2, + std::shared_ptr c2=synapse::connect(&e2, [&count]( int a1, float a2, std::string const & a3 ) { BOOST_TEST_EQ(a1, 42); @@ -290,20 +288,20 @@ namespace BOOST_TEST_EQ(count, 4); BOOST_TEST_EQ(connect_count, 2); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c1.reset(); BOOST_TEST_EQ(connect_count, 1); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c0.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } @@ -319,24 +317,24 @@ namespace int count=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c0 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c0.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c1 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e1]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e1,c,flags); } ) ); BOOST_TEST(mc_c1.unique()); BOOST_TEST_EQ(connect_count, 0); - shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc_c2 = release( synapse::connect >(synapse::meta::emitter(), [&connect_count,&e2]( synapse::connection & c, unsigned flags ) { test_meta_callback_connect(connect_count,&e2,c,flags); } ) ); BOOST_TEST(mc_c2.unique()); BOOST_TEST_EQ(connect_count, 0); short a4=42; - shared_ptr c0=synapse::translate(&e1,&e1); + std::shared_ptr c0=synapse::translate(&e1,&e1); BOOST_TEST_EQ(connect_count, 1); - shared_ptr c1=synapse::translate(&e1,&e2); + std::shared_ptr c1=synapse::translate(&e1,&e2); BOOST_TEST_EQ(connect_count, 2); - shared_ptr c2=synapse::connect(&e2, + std::shared_ptr c2=synapse::connect(&e2, [&count,&a4]( int a1, float a2, std::string const & a3, short & a4_ ) { BOOST_TEST_EQ(a1, 42); @@ -363,20 +361,20 @@ namespace BOOST_TEST_EQ(count, 4); BOOST_TEST_EQ(connect_count, 2); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c1.reset(); BOOST_TEST_EQ(connect_count, 1); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } c0.reset(); BOOST_TEST_EQ(connect_count, 0); { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); - BOOST_TEST(!weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(weak_ptr())); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + BOOST_TEST(!std::weak_ptr().owner_before(tlsd->cl_) && !tlsd->cl_.owner_before(std::weak_ptr())); } } diff --git a/test/block_emit_test.cpp b/test/block_emit_test.cpp index 6755978..d91e712 100644 --- a/test/block_emit_test.cpp +++ b/test/block_emit_test.cpp @@ -9,7 +9,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; namespace { @@ -17,7 +16,7 @@ namespace bool emitter_blocked( void const * e ) { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); return tlsd && tlsd->emitter_blocked_(*tlsd,e); } typedef struct my_signal_(*my_signal)(); @@ -28,14 +27,14 @@ int main( int argc, char const * argv[] ) int e1, e2; BOOST_TEST(!emitter_blocked(&e1)); BOOST_TEST(!emitter_blocked(&e2)); - shared_ptr b1=synapse::block(&e1); + std::shared_ptr b1=synapse::block(&e1); BOOST_TEST(emitter_blocked(&e1)); BOOST_TEST(!emitter_blocked(&e2)); - shared_ptr b2=synapse::block(&e2); + std::shared_ptr b2=synapse::block(&e2); BOOST_TEST(emitter_blocked(&e1)); BOOST_TEST(emitter_blocked(&e2)); int count=0; - shared_ptr c=synapse::connect(&e1,[&count]() { ++count; } ); + std::shared_ptr c=synapse::connect(&e1,[&count]() { ++count; } ); BOOST_TEST_EQ(synapse::emit(&e1), 0); BOOST_TEST_EQ(count, 0); b1.reset(); diff --git a/test/block_test.cpp b/test/block_test.cpp index 5c3494a..2de8b84 100644 --- a/test/block_test.cpp +++ b/test/block_test.cpp @@ -8,8 +8,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; namespace { @@ -17,7 +15,7 @@ namespace struct meta_data { - shared_ptr e; + std::shared_ptr e; my_emitter_type * ep; synapse::blocker * eb; int count; @@ -37,15 +35,15 @@ namespace } }; - bool does_not_own( shared_ptr const & e ) + bool does_not_own( std::shared_ptr const & e ) { - return !(e.owner_before(shared_ptr())) && !(shared_ptr().owner_before(e)); + return !(e.owner_before(std::shared_ptr())) && !(std::shared_ptr().owner_before(e)); } template bool emitter_blocked( void const * e ) { - shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); + std::shared_ptr const & tlsd=synapse::synapse_detail::get_thread_local_signal_data(false); return tlsd && tlsd->emitter_blocked_(*tlsd,e); } @@ -91,10 +89,10 @@ namespace BOOST_TEST(!emitter_blocked(&e1)); BOOST_TEST(!emitter_blocked(&e2)); BOOST_TEST(!emitter_blocked(&e2)); - shared_ptr eb1=synapse::block(&e1); + std::shared_ptr eb1=synapse::block(&e1); { - shared_ptr b1=synapse::block(&e1); - shared_ptr b2=synapse::block(&e1); + std::shared_ptr b1=synapse::block(&e1); + std::shared_ptr b2=synapse::block(&e1); BOOST_TEST_EQ(eb1, b1); BOOST_TEST_EQ(eb1, b2); } @@ -107,10 +105,10 @@ namespace BOOST_TEST(!emitter_blocked(&e1)); BOOST_TEST(!emitter_blocked(&e2)); BOOST_TEST(!emitter_blocked(&e2)); - shared_ptr eb2=synapse::block(&e1); + std::shared_ptr eb2=synapse::block(&e1); { - shared_ptr b1=synapse::block(&e1); - shared_ptr b2=synapse::block(&e1); + std::shared_ptr b1=synapse::block(&e1); + std::shared_ptr b2=synapse::block(&e1); BOOST_TEST_EQ(eb2, b1); BOOST_TEST_EQ(eb2, b2); } @@ -123,10 +121,10 @@ namespace BOOST_TEST(emitter_blocked(&e1)); BOOST_TEST(!emitter_blocked(&e2)); BOOST_TEST(!emitter_blocked(&e2)); - shared_ptr eb3=synapse::block(&e2); + std::shared_ptr eb3=synapse::block(&e2); { - shared_ptr b1=synapse::block(&e2); - shared_ptr b2=synapse::block(&e2); + std::shared_ptr b1=synapse::block(&e2); + std::shared_ptr b2=synapse::block(&e2); BOOST_TEST_EQ(eb3, b1); BOOST_TEST_EQ(eb3, b2); } @@ -139,10 +137,10 @@ namespace BOOST_TEST(emitter_blocked(&e1)); BOOST_TEST(emitter_blocked(&e2)); BOOST_TEST(!emitter_blocked(&e2)); - shared_ptr eb4=synapse::block(&e2); + std::shared_ptr eb4=synapse::block(&e2); { - shared_ptr b1=synapse::block(&e2); - shared_ptr b2=synapse::block(&e2); + std::shared_ptr b1=synapse::block(&e2); + std::shared_ptr b2=synapse::block(&e2); BOOST_TEST_EQ(eb4, b1); BOOST_TEST_EQ(eb4, b2); } @@ -174,8 +172,8 @@ namespace eb3.reset(); BOOST_TEST(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_.expired()); BOOST_TEST( - !(weak_ptr().owner_before(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_)) && - !(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_.owner_before(weak_ptr())) ); + !(std::weak_ptr().owner_before(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_)) && + !(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_.owner_before(std::weak_ptr())) ); BOOST_TEST(does_not_own(the_meta_data().e)); BOOST_TEST_EQ(the_meta_data().ep, &e2); BOOST_TEST_EQ(the_meta_data().eb, eb); @@ -205,8 +203,8 @@ namespace eb4.reset(); BOOST_TEST(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_.expired()); BOOST_TEST( - !(weak_ptr().owner_before(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_)) && - !(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_.owner_before(weak_ptr())) ); + !(std::weak_ptr().owner_before(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_)) && + !(synapse::synapse_detail::get_thread_local_signal_data(false)->bl_.owner_before(std::weak_ptr())) ); BOOST_TEST(does_not_own(the_meta_data().e)); BOOST_TEST_EQ(the_meta_data().ep, &e2); BOOST_TEST_EQ(the_meta_data().eb, eb); @@ -220,13 +218,13 @@ namespace } { - shared_ptr e(new my_emitter_type); + std::shared_ptr e(new my_emitter_type); BOOST_TEST(!emitter_blocked(e.get())); BOOST_TEST(the_meta_data().count==0); - shared_ptr eb=synapse::block(e); + std::shared_ptr eb=synapse::block(e); { - shared_ptr b1=synapse::block(e); - shared_ptr b2=synapse::block(e); + std::shared_ptr b1=synapse::block(e); + std::shared_ptr b2=synapse::block(e); BOOST_TEST_EQ(eb, b1); BOOST_TEST_EQ(eb, b2); } @@ -253,13 +251,13 @@ namespace } { - shared_ptr e(new my_emitter_type); + std::shared_ptr e(new my_emitter_type); BOOST_TEST(!emitter_blocked(e.get())); BOOST_TEST_EQ(the_meta_data().count, 0); - shared_ptr eb=synapse::block(weak_ptr(e)); + std::shared_ptr eb=synapse::block(std::weak_ptr(e)); { - shared_ptr b1=synapse::block(e); - shared_ptr b2=synapse::block(e); + std::shared_ptr b1=synapse::block(e); + std::shared_ptr b2=synapse::block(e); BOOST_TEST_EQ(eb, b1); BOOST_TEST_EQ(eb, b2); } @@ -291,13 +289,13 @@ namespace void emitter_address_reuse_test() { my_emitter_type e2; - shared_ptr e1(&e2,null_deleter()); - shared_ptr b1=synapse::block(e1); + std::shared_ptr e1(&e2,null_deleter()); + std::shared_ptr b1=synapse::block(e1); BOOST_TEST(emitter_blocked(&e2)); BOOST_TEST_EQ(b1.use_count(), 1); e1.reset(); the_meta_data().reset(); - shared_ptr b2=synapse::block(&e2); + std::shared_ptr b2=synapse::block(&e2); BOOST_TEST(emitter_blocked(&e2)); BOOST_TEST_EQ(b2.use_count(), 1); the_meta_data().reset(); diff --git a/test/connect_emit_test.cpp b/test/connect_emit_test.cpp index 1ca3be0..b7fe210 100644 --- a/test/connect_emit_test.cpp +++ b/test/connect_emit_test.cpp @@ -8,8 +8,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; using namespace std::placeholders; typedef struct test_signal1_(*test_signal1)(); typedef struct test_signal2_(*test_signal2)(); @@ -23,9 +21,9 @@ namespace int count2=0; BOOST_TEST_EQ(synapse::emit(&emitter), 0); BOOST_TEST_EQ(synapse::emit(&emitter), 0); - shared_ptr c1 = synapse::connect( &emitter, [&count1](){++count1;} ); + std::shared_ptr c1 = synapse::connect( &emitter, [&count1](){++count1;} ); BOOST_TEST(c1.unique()); - shared_ptr c2 = synapse::connect( &emitter, [&count2](){++count2;} ); + std::shared_ptr c2 = synapse::connect( &emitter, [&count2](){++count2;} ); BOOST_TEST(c2.unique()); BOOST_TEST_EQ(synapse::emit(&emitter), 1); BOOST_TEST_EQ(count1, 1); @@ -57,9 +55,9 @@ namespace int count2=0; BOOST_TEST_EQ(synapse::emit(&emitter), 0); BOOST_TEST_EQ(synapse::emit(&emitter), 0); - shared_ptr c1 = synapse::connect( &emitter, &receiver, [&count1,&receiver]( int * r ){ BOOST_TEST(r==&receiver); ++count1;} ); + std::shared_ptr c1 = synapse::connect( &emitter, &receiver, [&count1,&receiver]( int * r ){ BOOST_TEST(r==&receiver); ++count1;} ); BOOST_TEST(c1.unique()); - shared_ptr c2 = synapse::connect( &emitter, &receiver, [&count2,&receiver]( int * r ){ BOOST_TEST(r==&receiver); ++count2;} ); + std::shared_ptr c2 = synapse::connect( &emitter, &receiver, [&count2,&receiver]( int * r ){ BOOST_TEST(r==&receiver); ++count2;} ); BOOST_TEST(c2.unique()); BOOST_TEST_EQ(synapse::emit(&emitter), 1); BOOST_TEST_EQ(count1, 1); @@ -107,9 +105,9 @@ namespace test_class receiver2(count2); BOOST_TEST_EQ(synapse::emit(&emitter), 0); BOOST_TEST_EQ(synapse::emit(&emitter), 0); - shared_ptr c1 = synapse::connect( &emitter, &receiver1, &test_class::fn ); + std::shared_ptr c1 = synapse::connect( &emitter, &receiver1, &test_class::fn ); BOOST_TEST(c1.unique()); - shared_ptr c2 = synapse::connect( &emitter, &receiver2, &test_class::fn ); + std::shared_ptr c2 = synapse::connect( &emitter, &receiver2, &test_class::fn ); BOOST_TEST(c2.unique()); BOOST_TEST_EQ(synapse::emit(&emitter), 1); BOOST_TEST_EQ(count1, 1); @@ -142,9 +140,9 @@ namespace test_class receiver2(count2); BOOST_TEST_EQ(synapse::emit(&emitter), 0); BOOST_TEST_EQ(synapse::emit(&emitter), 0); - shared_ptr c1 = synapse::connect( &emitter, &receiver1, std::bind(&test_class::fn,_1) ); + std::shared_ptr c1 = synapse::connect( &emitter, &receiver1, std::bind(&test_class::fn,_1) ); BOOST_TEST(c1.unique()); - shared_ptr c2 = synapse::connect( &emitter, &receiver2, std::bind(&test_class::fn,_1) ); + std::shared_ptr c2 = synapse::connect( &emitter, &receiver2, std::bind(&test_class::fn,_1) ); BOOST_TEST(c2.unique()); BOOST_TEST_EQ(synapse::emit(&emitter), 1); BOOST_TEST_EQ(count1, 1); diff --git a/test/connection_lifetime_test.cpp b/test/connection_lifetime_test.cpp index fa32543..9878a70 100644 --- a/test/connection_lifetime_test.cpp +++ b/test/connection_lifetime_test.cpp @@ -8,8 +8,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; namespace { @@ -36,11 +34,11 @@ namespace { BOOST_TEST_EQ(connection_count, 0); { - shared_ptr em=make_shared(42); - shared_ptr c1=synapse::connect(&em,[ ]( ){ }); - shared_ptr c2=release(synapse::connect(em,[ ]( ){ })); - c1->set_user_data(make_shared()); - c2->set_user_data(make_shared()); + std::shared_ptr em=std::make_shared(42); + std::shared_ptr c1=synapse::connect(&em,[ ]( ){ }); + std::shared_ptr c2=release(synapse::connect(em,[ ]( ){ })); + c1->set_user_data(std::make_shared()); + c2->set_user_data(std::make_shared()); BOOST_TEST_EQ(connection_count, 2); em.reset(); BOOST_TEST_EQ(connection_count, 2); @@ -53,12 +51,12 @@ namespace int count1=0, count2=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr c1=synapse::connect(&e1,[&count1]() { ++count1; } ); - shared_ptr c2=synapse::connect(&e2,[&count2]() { ++count2; } ); - shared_ptr c3=synapse::connect(&e1,[&count1]() { ++count1; } ); - shared_ptr c4=synapse::connect(&e2,[&count2]() { ++count2; } ); - shared_ptr c5=synapse::connect(&e1,[&count1]() { ++count1; } ); - shared_ptr c6=synapse::connect(&e2,[&count2]() { ++count2; } ); + std::shared_ptr c1=synapse::connect(&e1,[&count1]() { ++count1; } ); + std::shared_ptr c2=synapse::connect(&e2,[&count2]() { ++count2; } ); + std::shared_ptr c3=synapse::connect(&e1,[&count1]() { ++count1; } ); + std::shared_ptr c4=synapse::connect(&e2,[&count2]() { ++count2; } ); + std::shared_ptr c5=synapse::connect(&e1,[&count1]() { ++count1; } ); + std::shared_ptr c6=synapse::connect(&e2,[&count2]() { ++count2; } ); BOOST_TEST_EQ(synapse::emit(&e1), 3); BOOST_TEST_EQ(count1, 3); BOOST_TEST_EQ(count2, 0); @@ -122,12 +120,12 @@ namespace int count1=0, count2=0; my_emitter_type e1; my_emitter_type e2; - shared_ptr lt1(new int(1)); - shared_ptr lt2(new int(2)); - shared_ptr lt3(new int(3)); - shared_ptr lt4(new int(4)); - shared_ptr lt5(new int(5)); - shared_ptr lt6(new int(6)); + std::shared_ptr lt1(new int(1)); + std::shared_ptr lt2(new int(2)); + std::shared_ptr lt3(new int(3)); + std::shared_ptr lt4(new int(4)); + std::shared_ptr lt5(new int(5)); + std::shared_ptr lt6(new int(6)); (void) synapse::connect(&e1,lt1,[&count1]( int * x ) { BOOST_TEST_EQ(*x, 1); ++count1; }); (void) synapse::connect(&e2,lt2,[&count2]( int * x ) { BOOST_TEST_EQ(*x, 2); ++count2; }); (void) synapse::connect(&e1,lt3,[&count1]( int * x ) { BOOST_TEST_EQ(*x, 3); ++count1; }); @@ -196,7 +194,7 @@ namespace { int count=0; my_emitter_type e; - shared_ptr e1(&e,null_deleter()); + std::shared_ptr e1(&e,null_deleter()); (void) synapse::connect(e1,[&count](){ ++count; }); e1.reset(); BOOST_TEST_EQ(count, 0); diff --git a/test/connection_user_data_test.cpp b/test/connection_user_data_test.cpp index dbc57f2..cca8ff3 100644 --- a/test/connection_user_data_test.cpp +++ b/test/connection_user_data_test.cpp @@ -8,9 +8,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; - namespace { struct my_emitter_type { }; @@ -24,14 +21,14 @@ int main( int argc, char const * argv[] ) { { my_emitter_type e; - shared_ptr c=synapse::connect(&e,&noop); + std::shared_ptr c=synapse::connect(&e,&noop); BOOST_TEST(!c->get_user_data()); c->set_user_data(42); BOOST_TEST_EQ(*c->get_user_data(), 42); } { - auto e = make_shared(); - shared_ptr c=synapse::connect(e,&noop).lock(); + auto e = std::make_shared(); + std::shared_ptr c=synapse::connect(e,&noop).lock(); BOOST_TEST(!c->get_user_data()); c->set_user_data(42); BOOST_TEST_EQ(*c->get_user_data(), 42); diff --git a/test/ct_basic_test.cpp b/test/ct_basic_test.cpp index 9d55d8e..c8268a2 100644 --- a/test/ct_basic_test.cpp +++ b/test/ct_basic_test.cpp @@ -11,7 +11,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse = boost::synapse; -using synapse::shared_ptr; namespace { @@ -21,8 +20,8 @@ namespace void emitting_thread( int consuming_thread_count, int iterations ) { - int local_count1=0; shared_ptr c1=synapse::connect(&emitter, [&local_count1]() { ++local_count1; } ); - int local_count2=0; shared_ptr c2=synapse::connect(&emitter, [&local_count2]() { ++local_count2; } ); + int local_count1=0; std::shared_ptr c1=synapse::connect(&emitter, [&local_count1]() { ++local_count1; } ); + int local_count2=0; std::shared_ptr c2=synapse::connect(&emitter, [&local_count2]() { ++local_count2; } ); for( int i=0; i!=iterations; ++i ) { int n1=synapse::emit(&emitter); @@ -37,9 +36,9 @@ namespace void consuming_thread( barrier & b, int total_count ) { assert(total_count>0); - int n1=0; shared_ptr c1=synapse::connect(&emitter, [&n1]() { ++n1; } ); - shared_ptr tlq=synapse::create_thread_local_queue(); - int n2=0; shared_ptr c2=synapse::connect(&emitter, [&n2]() { ++n2; } ); + int n1=0; std::shared_ptr c1=synapse::connect(&emitter, [&n1]() { ++n1; } ); + std::shared_ptr tlq=synapse::create_thread_local_queue(); + int n2=0; std::shared_ptr c2=synapse::connect(&emitter, [&n2]() { ++n2; } ); b.wait(); while( n1!=total_count || n2!=total_count ) { diff --git a/test/ct_lambda_test.cpp b/test/ct_lambda_test.cpp index eefc957..e5cf886 100644 --- a/test/ct_lambda_test.cpp +++ b/test/ct_lambda_test.cpp @@ -10,18 +10,16 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; namespace { int const thread_count=10; int const iteration_count=1000; - void emitting_thread( weak_ptr tlq, int & counter, std::thread::id tid ) + void emitting_thread( std::weak_ptr tlq, int & counter, std::thread::id tid ) { for(;;) - if( shared_ptr p=tlq.lock() ) + if( std::shared_ptr p=tlq.lock() ) post( *p, [&counter, tid]() { BOOST_TEST_EQ(std::this_thread::get_id(), tid); @@ -35,7 +33,7 @@ namespace { assert(iteration_count>0); int count=0; - shared_ptr tlq=synapse::create_thread_local_queue(); + std::shared_ptr tlq=synapse::create_thread_local_queue(); std::thread::id const tid = std::this_thread::get_id(); std::thread th( [&] { diff --git a/test/ct_tlq_lifetime_test.cpp b/test/ct_tlq_lifetime_test.cpp index 232823f..d7a6443 100644 --- a/test/ct_tlq_lifetime_test.cpp +++ b/test/ct_tlq_lifetime_test.cpp @@ -12,9 +12,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; -using synapse::make_shared; namespace { @@ -42,15 +39,15 @@ namespace } }; - void emitting_thread( barrier & b, weak_ptr const & terminate ) + void emitting_thread( barrier & b, std::weak_ptr const & terminate ) { - shared_ptr tlq=synapse::create_thread_local_queue(); + std::shared_ptr tlq=synapse::create_thread_local_queue(); bool keep_going=true; synapse::connect( terminate, [&keep_going] { keep_going=false; - }).lock()->set_user_data(make_shared()); + }).lock()->set_user_data(std::make_shared()); b.wait(); while( keep_going ) { @@ -67,7 +64,7 @@ namespace assert(series_count>0); std::cout << "*** " << emitting_thread_count << '/' << per_thread_emit_count << '/' << series_count << " ***" << std::endl; barrier b( emitting_thread_count + 1 ); - shared_ptr terminate(make_shared(42)); + std::shared_ptr terminate(std::make_shared(42)); std::vector tgr; tgr.reserve(emitting_thread_count); for( int i=0; i!=emitting_thread_count; ++i ) @@ -79,11 +76,11 @@ namespace b.wait(); BOOST_TEST(terminate.unique()); BOOST_TEST_EQ(connection_count, emitting_thread_count); - shared_ptr c1=synapse::connect(&emitter,[](){}); - shared_ptr c2=synapse::connect(&emitter,[](){}); + std::shared_ptr c1=synapse::connect(&emitter,[](){}); + std::shared_ptr c2=synapse::connect(&emitter,[](){}); for( int i=0; i!=series_count; ++i ) { - shared_ptr tlq=synapse::create_thread_local_queue(); + std::shared_ptr tlq=synapse::create_thread_local_queue(); for( int j=0; j tlq=synapse::create_thread_local_queue(); - int counter1=0; shared_ptr c1=synapse::connect(&counter1,[&counter1](){++counter1;}); - int counter2=0; shared_ptr c2=synapse::connect(&counter2,[&counter2](){++counter2;}); + std::shared_ptr tlq=synapse::create_thread_local_queue(); + int counter1=0; std::shared_ptr c1=synapse::connect(&counter1,[&counter1](){++counter1;}); + int counter2=0; std::shared_ptr c2=synapse::connect(&counter2,[&counter2](){++counter2;}); std::thread th1( [&] { diff --git a/test/emit_test.cpp b/test/emit_test.cpp index 146b5ed..a2283d3 100644 --- a/test/emit_test.cpp +++ b/test/emit_test.cpp @@ -7,7 +7,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; namespace { @@ -18,15 +17,15 @@ namespace { my_emitter_type e; int count0=0, count1=0, count2=0; - shared_ptr c1; - shared_ptr c0=synapse::connect(&e, + std::shared_ptr c1; + std::shared_ptr c0=synapse::connect(&e, [&c1,&count0]() { if( ++count0==3 ) c1.reset(); } ); c1=synapse::connect(&e,[&count1]() { ++count1; } ); - shared_ptr c2=synapse::connect(&e,[&count2]() { ++count2; } ); + std::shared_ptr c2=synapse::connect(&e,[&count2]() { ++count2; } ); BOOST_TEST_EQ(synapse::emit(&e), 3); BOOST_TEST(c1); BOOST_TEST_EQ(count0, 1); @@ -48,15 +47,15 @@ namespace { my_emitter_type e; int count0=0, count1=0, count2=0; - shared_ptr lifetime(new int(42)); - shared_ptr c0=synapse::connect(&e, + std::shared_ptr lifetime(new int(42)); + std::shared_ptr c0=synapse::connect(&e, [&lifetime,&count0]() { if( ++count0==3 ) lifetime.reset(); } ); (void) synapse::connect(&e,lifetime,[&count1]( int * x ) { BOOST_TEST_EQ(*x, 42); ++count1; } ); - shared_ptr c2=synapse::connect(&e,[&count2]() { ++count2; } ); + std::shared_ptr c2=synapse::connect(&e,[&count2]() { ++count2; } ); BOOST_TEST_EQ(synapse::emit(&e), 3); BOOST_TEST(lifetime); BOOST_TEST_EQ(count0, 1); @@ -80,13 +79,13 @@ namespace { my_emitter_type e2; int n1=0; - shared_ptr e1(&e2,null_deleter()); + std::shared_ptr e1(&e2,null_deleter()); (void) synapse::connect(e1,[&n1]() { ++n1; } ); BOOST_TEST_EQ(synapse::emit(&e2), 1); BOOST_TEST_EQ(n1, 1); e1.reset(); int n2=0; - shared_ptr c2=synapse::connect(&e2,[&n2]() { ++n2; } ); + std::shared_ptr c2=synapse::connect(&e2,[&n2]() { ++n2; } ); BOOST_TEST_EQ(synapse::emit(&e2), 1); BOOST_TEST_EQ(n1, 1); BOOST_TEST_EQ(n2, 1); diff --git a/test/property_test.cpp b/test/property_test.cpp index dcbe1a9..706355b 100644 --- a/test/property_test.cpp +++ b/test/property_test.cpp @@ -8,7 +8,6 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; typedef synapse::property prop1; diff --git a/test/release_test.cpp b/test/release_test.cpp index 9e3f3ef..6d72400 100644 --- a/test/release_test.cpp +++ b/test/release_test.cpp @@ -7,9 +7,6 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; -using synapse::make_shared; typedef struct my_signal_(*my_signal)(); struct my_emitter { }; @@ -17,7 +14,7 @@ struct my_emitter { }; int main( int argc, char const * argv[] ) { int meta_counter=0; - shared_ptr mc=release(synapse::connect >(synapse::meta::emitter(), + std::shared_ptr mc=release(synapse::connect >(synapse::meta::emitter(), [&meta_counter]( synapse::connection & c, unsigned flags ) { if( flags&synapse::meta::connect_flags::connecting ) @@ -26,20 +23,20 @@ int main( int argc, char const * argv[] ) --meta_counter; })); - shared_ptr e1 = make_shared(); + std::shared_ptr e1 = std::make_shared(); int emit_counter1=0; BOOST_TEST_EQ(meta_counter, 0); - weak_ptr c1 = synapse::connect(e1, + std::weak_ptr c1 = synapse::connect(e1, [&emit_counter1]() { ++emit_counter1; }); BOOST_TEST(!c1.expired()); - shared_ptr e2 = make_shared(); + std::shared_ptr e2 = std::make_shared(); int emit_counter2=0; BOOST_TEST_EQ(meta_counter, 1); - weak_ptr c2 = synapse::connect(e2, + std::weak_ptr c2 = synapse::connect(e2, [&emit_counter2]() { ++emit_counter2; @@ -62,7 +59,7 @@ int main( int argc, char const * argv[] ) { BOOST_TEST(!c1.expired()); BOOST_TEST(!c2.expired()); - shared_ptr c=synapse::connect(&meta_counter,[ ]( ){ }); + std::shared_ptr c=synapse::connect(&meta_counter,[ ]( ){ }); BOOST_TEST(c1.expired()); BOOST_TEST(c2.expired()); BOOST_TEST_EQ(meta_counter, 1); diff --git a/test/shutdown_test1.cpp b/test/shutdown_test1.cpp index ed26880..d1e7d04 100644 --- a/test/shutdown_test1.cpp +++ b/test/shutdown_test1.cpp @@ -6,15 +6,13 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect( e, [ ] ( ) { } ); synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); return 0; diff --git a/test/shutdown_test2.cpp b/test/shutdown_test2.cpp index 985d829..a75de1f 100644 --- a/test/shutdown_test2.cpp +++ b/test/shutdown_test2.cpp @@ -6,15 +6,13 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); synapse::connect( e, [ ] ( ) { } ); return 0; diff --git a/test/shutdown_test3.cpp b/test/shutdown_test3.cpp index 59e9827..cd7ac34 100644 --- a/test/shutdown_test3.cpp +++ b/test/shutdown_test3.cpp @@ -6,8 +6,6 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); @@ -15,7 +13,7 @@ typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect( e, [ ] ( ) { } ); return 0; } diff --git a/test/shutdown_test4.cpp b/test/shutdown_test4.cpp index 79b10b8..b724037 100644 --- a/test/shutdown_test4.cpp +++ b/test/shutdown_test4.cpp @@ -6,15 +6,13 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect( e, [ ] ( ) { } ); auto connected = synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); return 0; diff --git a/test/shutdown_test5.cpp b/test/shutdown_test5.cpp index 77d3a7c..e083206 100644 --- a/test/shutdown_test5.cpp +++ b/test/shutdown_test5.cpp @@ -6,15 +6,13 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); auto connected = synapse::connect( e, [ ] ( ) { } ); return 0; diff --git a/test/shutdown_test6.cpp b/test/shutdown_test6.cpp index 9184989..0539543 100644 --- a/test/shutdown_test6.cpp +++ b/test/shutdown_test6.cpp @@ -6,8 +6,6 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); @@ -15,7 +13,7 @@ typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); auto connected = synapse::connect( e, [ ] ( ) { } ); return 0; } diff --git a/test/shutdown_test7.cpp b/test/shutdown_test7.cpp index c5464f1..4939bc0 100644 --- a/test/shutdown_test7.cpp +++ b/test/shutdown_test7.cpp @@ -6,15 +6,13 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect( e, [ ] ( ) { } ); auto connected = synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); exit(0); diff --git a/test/shutdown_test8.cpp b/test/shutdown_test8.cpp index 472d7e2..0c9eff4 100644 --- a/test/shutdown_test8.cpp +++ b/test/shutdown_test8.cpp @@ -6,15 +6,12 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; - struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); auto connected = synapse::connect( e, [ ] ( ) { } ); exit(0); diff --git a/test/shutdown_test9.cpp b/test/shutdown_test9.cpp index bff2fae..58e8b4a 100644 --- a/test/shutdown_test9.cpp +++ b/test/shutdown_test9.cpp @@ -6,8 +6,6 @@ #include namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::make_shared; struct my_emitter_type { }; typedef struct my_signal_(*my_signal)(); @@ -15,7 +13,7 @@ typedef struct my_signal_(*my_signal)(); int main( int argc, char const * argv[] ) { synapse::connect >( synapse::meta::emitter(), [ ]( synapse::connection &, unsigned ) { } ); - shared_ptr e=make_shared(); + std::shared_ptr e=std::make_shared(); auto connected = synapse::connect( e, [ ] ( ) { } ); exit(0); } diff --git a/test/weak_store_test.cpp b/test/weak_store_test.cpp index c904199..bb189c0 100644 --- a/test/weak_store_test.cpp +++ b/test/weak_store_test.cpp @@ -7,12 +7,10 @@ #include "boost/core/lightweight_test.hpp" namespace synapse=boost::synapse; -using synapse::shared_ptr; -using synapse::weak_ptr; struct test_type { test_type() { } }; -bool shared( shared_ptr const & a, shared_ptr const & b ) +bool shared( std::shared_ptr const & a, std::shared_ptr const & b ) { return !a.owner_before(b) && !b.owner_before(a); } @@ -27,10 +25,10 @@ int main( int argc, char const * argv[] ) BOOST_TEST_EQ(sx.maybe_lock().get(), &x); BOOST_TEST_EQ(sx.maybe_lock().get(), &x); BOOST_TEST_EQ(sx.maybe_lock().get(), &x); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); BOOST_TEST(!sx.empty()); BOOST_TEST(!sx.expired()); sx.clear(); @@ -45,10 +43,10 @@ int main( int argc, char const * argv[] ) BOOST_TEST(!sx.maybe_lock()); BOOST_TEST_EQ(sx.maybe_lock().get(), &x); BOOST_TEST(!sx.maybe_lock()); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); BOOST_TEST(!sx.empty()); BOOST_TEST(!sx.expired()); sx.clear(); @@ -56,8 +54,8 @@ int main( int argc, char const * argv[] ) BOOST_TEST(sx.expired()); } { - shared_ptr x(new test_type); - synapse::synapse_detail::weak_store sx=synapse::synapse_detail::weak_store(weak_ptr(x)); + std::shared_ptr x(new test_type); + synapse::synapse_detail::weak_store sx=synapse::synapse_detail::weak_store(std::weak_ptr(x)); BOOST_TEST(sx.lockable()); BOOST_TEST_EQ(sx.maybe_lock(), x); BOOST_TEST_EQ(sx.maybe_lock(), x); @@ -81,17 +79,17 @@ int main( int argc, char const * argv[] ) BOOST_TEST(sx.expired()); } { - shared_ptr x(new test_type); - synapse::synapse_detail::weak_store sx=synapse::synapse_detail::weak_store(weak_ptr(x)); + std::shared_ptr x(new test_type); + synapse::synapse_detail::weak_store sx=synapse::synapse_detail::weak_store(std::weak_ptr(x)); BOOST_TEST(sx.lockable()); BOOST_TEST_EQ(sx.maybe_lock(), x); BOOST_TEST(!sx.maybe_lock()); BOOST_TEST_EQ(sx.maybe_lock(), x); BOOST_TEST(!sx.maybe_lock()); BOOST_TEST(shared(sx.maybe_lock(),x)); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); BOOST_TEST(shared(sx.maybe_lock(),x)); - BOOST_TEST(shared(sx.maybe_lock(),shared_ptr())); + BOOST_TEST(shared(sx.maybe_lock(),std::shared_ptr())); BOOST_TEST(!sx.empty()); BOOST_TEST(!sx.expired()); x.reset();