From dceee3b065ba64a770ef836fade38fae34bac09c Mon Sep 17 00:00:00 2001 From: Arvid Norberg Date: Sat, 21 May 2016 19:05:42 -0400 Subject: [PATCH] simplify session call and replace session_handle and torrent_handle macros (#741) remove use of macros in session_handle and torrent_handle forwarders --- include/libtorrent/aux_/session_call.hpp | 57 +--- include/libtorrent/aux_/session_impl.hpp | 11 +- include/libtorrent/session_handle.hpp | 10 + include/libtorrent/torrent.hpp | 17 +- include/libtorrent/torrent_handle.hpp | 11 + src/http_seed_connection.cpp | 16 +- src/session_call.cpp | 19 -- src/session_handle.cpp | 258 ++++++++-------- src/session_impl.cpp | 8 +- src/torrent.cpp | 49 ++- src/torrent_handle.cpp | 366 ++++++++++------------- src/web_peer_connection.cpp | 8 +- 12 files changed, 363 insertions(+), 467 deletions(-) diff --git a/include/libtorrent/aux_/session_call.hpp b/include/libtorrent/aux_/session_call.hpp index a9a443818..66977f6dc 100644 --- a/include/libtorrent/aux_/session_call.hpp +++ b/include/libtorrent/aux_/session_call.hpp @@ -37,70 +37,15 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/aux_/session_impl.hpp" #include +#include namespace libtorrent { namespace aux { void blocking_call(); void dump_call_profile(); -void fun_wrap(bool& done, std::condition_variable& e, std::mutex& m, boost::function f); - -template -void fun_ret(R& ret, bool& done, std::condition_variable& e, std::mutex& m, boost::function f) -{ - ret = f(); - std::unique_lock l(m); - done = true; - e.notify_all(); -} - void torrent_wait(bool& done, aux::session_impl& ses); -void sync_call(aux::session_impl& ses, boost::function f); - -template -void sync_call_handle(Handle& h, boost::function f) -{ - bool done = false; - session_impl& ses = static_cast(h->session()); - ses.get_io_service().dispatch(boost::bind(&aux::fun_wrap - , boost::ref(done) - , boost::ref(ses.cond) - , boost::ref(ses.mut), f)); - h.reset(); - aux::torrent_wait(done, ses); -} - -template -Ret sync_call_ret(aux::session_impl& ses, boost::function f) -{ - bool done = false; - Ret r; - ses.get_io_service().dispatch(boost::bind(&fun_ret - , boost::ref(r) - , boost::ref(done) - , boost::ref(ses.cond) - , boost::ref(ses.mut) - , f)); - torrent_wait(done, ses); - return r; -} - -template -void sync_call_ret_handle(Handle& h, Ret& r, boost::function f) -{ - bool done = false; - session_impl& ses = static_cast(h->session()); - ses.get_io_service().dispatch(boost::bind(&aux::fun_ret - , boost::ref(r) - , boost::ref(done) - , boost::ref(ses.cond) - , boost::ref(ses.mut) - , f)); - h.reset(); - aux::torrent_wait(done, ses); -} - } } // namespace aux namespace libtorrent #endif // TORRENT_SESSION_CALL_HPP_INCLUDED diff --git a/include/libtorrent/aux_/session_impl.hpp b/include/libtorrent/aux_/session_impl.hpp index a0ca5d7c0..dd1cee8d0 100644 --- a/include/libtorrent/aux_/session_impl.hpp +++ b/include/libtorrent/aux_/session_impl.hpp @@ -339,7 +339,8 @@ namespace libtorrent void dht_get_peers(sha1_hash const& info_hash); void dht_announce(sha1_hash const& info_hash, int port = 0, int flags = 0); - void dht_direct_request(udp::endpoint ep, entry& e, void* userdata = 0); + void dht_direct_request(udp::endpoint ep, entry& e + , void* userdata = 0); #ifndef TORRENT_NO_DEPRECATE entry dht_state() const; @@ -443,15 +444,15 @@ namespace libtorrent void pop_alerts(); alert const* pop_alert(); size_t set_alert_queue_size_limit(size_t queue_size_limit_); - int upload_rate_limit() const; - int download_rate_limit() const; + int upload_rate_limit_depr() const; + int download_rate_limit_depr() const; int local_upload_rate_limit() const; int local_download_rate_limit() const; void set_local_download_rate_limit(int bytes_per_second); void set_local_upload_rate_limit(int bytes_per_second); - void set_download_rate_limit(int bytes_per_second); - void set_upload_rate_limit(int bytes_per_second); + void set_download_rate_limit_depr(int bytes_per_second); + void set_upload_rate_limit_depr(int bytes_per_second); void set_max_connections(int limit); void set_max_uploads(int limit); diff --git a/include/libtorrent/session_handle.hpp b/include/libtorrent/session_handle.hpp index b181bc9c7..0bdc837ce 100644 --- a/include/libtorrent/session_handle.hpp +++ b/include/libtorrent/session_handle.hpp @@ -1021,6 +1021,16 @@ namespace libtorrent { return m_impl; } private: + + template + void async_call(Fun f, Args&&... a) const; + + template + void sync_call(Fun f, Args&&... a) const; + + template + Ret sync_call_ret(Fun f, Args&&... a) const; + aux::session_impl* m_impl; }; diff --git a/include/libtorrent/torrent.hpp b/include/libtorrent/torrent.hpp index a840edeb1..3ac7ca81a 100644 --- a/include/libtorrent/torrent.hpp +++ b/include/libtorrent/torrent.hpp @@ -296,7 +296,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_EXTENSIONS void add_extension(boost::shared_ptr); void remove_extension(boost::shared_ptr); - void add_extension(boost::function(torrent_handle const&, void*)> const& ext + void add_extension_fun(boost::function(torrent_handle const&, void*)> const& ext , void* userdata); void notify_extension_add_peer(tcp::endpoint const& ip, int src, int flags); #endif @@ -508,7 +508,7 @@ namespace libtorrent void filtered_pieces(std::vector& bitmask) const; void filter_files(std::vector const& files); #if !TORRENT_NO_FPU - void file_progress(std::vector& fp); + void file_progress_float(std::vector& fp); #endif // ============ end deprecation ============= @@ -579,16 +579,17 @@ namespace libtorrent // add or remove a url that will be attempted for // finding the file(s) in this torrent. - void add_web_seed(std::string const& url, web_seed_t::type_t type); - void add_web_seed(std::string const& url, web_seed_t::type_t type - , std::string const& auth, web_seed_t::headers_t const& extra_headers); + void add_web_seed(std::string const& url + , web_seed_t::type_t type + , std::string const& auth = std::string() + , web_seed_t::headers_t const& extra_headers = web_seed_entry::headers_t()); void remove_web_seed(std::string const& url, web_seed_t::type_t type); void disconnect_web_seed(peer_connection* p); void retry_web_seed(peer_connection* p, int retry = 0); - void remove_web_seed(peer_connection* p, error_code const& ec + void remove_web_seed_conn(peer_connection* p, error_code const& ec , operation_t op, int error = 0); std::set web_seeds(web_seed_entry::type_t type) const; @@ -747,7 +748,7 @@ namespace libtorrent return m_super_seeding && is_seed(); } - void super_seeding(bool on); + void set_super_seeding(bool on); int get_piece_to_super_seed(bitfield const&); // returns true if we have downloaded the given piece @@ -864,7 +865,7 @@ namespace libtorrent // remove a web seed, or schedule it for removal in case there // are outstanding operations on it - void remove_web_seed(std::list::iterator web); + void remove_web_seed_iter(std::list::iterator web); // this is called when the torrent has finished. i.e. // all the pieces we have not filtered have been downloaded. diff --git a/include/libtorrent/torrent_handle.hpp b/include/libtorrent/torrent_handle.hpp index 7ae67d1e6..f81c6d689 100644 --- a/include/libtorrent/torrent_handle.hpp +++ b/include/libtorrent/torrent_handle.hpp @@ -241,6 +241,8 @@ namespace libtorrent // with just set_flags() and clear_flags() using the flags from // add_torrent_params. Perhaps those flags should have a more generic // name. + + // TODO: 4 remove some of these friends friend class invariant_access; friend struct aux::session_impl; friend class session; @@ -1281,6 +1283,15 @@ namespace libtorrent private: + template + void async_call(Fun f, Args&&... a) const; + + template + void sync_call(Fun f, Args&&... a) const; + + template + Ret sync_call_ret(Ret def, Fun f, Args&&... a) const; + torrent_handle(boost::weak_ptr const& t) { if (!t.expired()) m_torrent = t; } diff --git a/src/http_seed_connection.cpp b/src/http_seed_connection.cpp index 8b68f22dc..f7932857b 100644 --- a/src/http_seed_connection.cpp +++ b/src/http_seed_connection.cpp @@ -107,7 +107,7 @@ namespace libtorrent peer_connection::disconnect(ec, op, error); if (t) t->disconnect_web_seed(this); } - + boost::optional http_seed_connection::downloading_piece_progress() const { @@ -269,9 +269,9 @@ namespace libtorrent } TORRENT_ASSERT(recv_buffer.left() == 0 || *recv_buffer.begin == 'H'); - + TORRENT_ASSERT(recv_buffer.left() <= m_recv_buffer.packet_size()); - + // this means the entire status line hasn't been received yet if (m_parser.status_code() == -1) { @@ -320,13 +320,13 @@ namespace libtorrent if (location.empty()) { // we should not try this server again. - t->remove_web_seed(this, errors::missing_location, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::missing_location, op_bittorrent, 2); return; } - + // add the redirected url and remove the current one t->add_web_seed(location, web_seed_entry::http_seed); - t->remove_web_seed(this, errors::redirecting, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::redirecting, op_bittorrent, 2); return; } @@ -345,14 +345,14 @@ namespace libtorrent { received_bytes(0, int(bytes_transferred)); // we should not try this server again. - t->remove_web_seed(this, errors::no_content_length, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::no_content_length, op_bittorrent, 2); return; } if (m_response_left != front_request.length) { received_bytes(0, int(bytes_transferred)); // we should not try this server again. - t->remove_web_seed(this, errors::invalid_range, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::invalid_range, op_bittorrent, 2); return; } m_body_start = m_parser.body_start(); diff --git a/src/session_call.cpp b/src/session_call.cpp index 96f5132e7..7c068fd15 100644 --- a/src/session_call.cpp +++ b/src/session_call.cpp @@ -71,14 +71,6 @@ void dump_call_profile() #endif } -void fun_wrap(bool& done, std::condition_variable& e, std::mutex& m, boost::function f) -{ - f(); - std::unique_lock l(m); - done = true; - e.notify_all(); -} - void torrent_wait(bool& done, aux::session_impl& ses) { blocking_call(); @@ -86,15 +78,4 @@ void torrent_wait(bool& done, aux::session_impl& ses) while (!done) { ses.cond.wait(l); }; } -void sync_call(aux::session_impl& ses, boost::function f) -{ - bool done = false; - ses.get_io_service().dispatch(boost::bind(&fun_wrap - , boost::ref(done) - , boost::ref(ses.cond) - , boost::ref(ses.mut) - , f)); - torrent_wait(done, ses); -} - } } // namespace aux namespace libtorrent diff --git a/src/session_handle.cpp b/src/session_handle.cpp index 3e5eeef21..dda816683 100644 --- a/src/session_handle.cpp +++ b/src/session_handle.cpp @@ -36,74 +36,67 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/torrent.hpp" #include "libtorrent/lazy_entry.hpp" +#include + #ifndef TORRENT_NO_DEPRECATE #include "libtorrent/read_resume_data.hpp" #endif -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-macros" -#endif - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunused-macros" -#endif - -#define TORRENT_ASYNC_CALL(x) \ - m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl)) - -#define TORRENT_ASYNC_CALL1(x, a1) \ - m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl, a1)) - -#define TORRENT_ASYNC_CALL2(x, a1, a2) \ - m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl, a1, a2)) - -#define TORRENT_ASYNC_CALL3(x, a1, a2, a3) \ - m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl, a1, a2, a3)) - -#define TORRENT_SYNC_CALL(x) \ - aux::sync_call(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl))) - -#define TORRENT_SYNC_CALL1(x, a1) \ - aux::sync_call(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1))) - -#define TORRENT_SYNC_CALL2(x, a1, a2) \ - aux::sync_call(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1, a2))) - -#define TORRENT_SYNC_CALL3(x, a1, a2, a3) \ - aux::sync_call(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1, a2, a3))) - -#define TORRENT_SYNC_CALL4(x, a1, a2, a3, a4) \ - aux::sync_call(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1, a2, a3, a4))) - -#define TORRENT_SYNC_CALL_RET(type, x) \ - aux::sync_call_ret(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl))) - -#define TORRENT_SYNC_CALL_RET1(type, x, a1) \ - aux::sync_call_ret(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1))) - -#define TORRENT_SYNC_CALL_RET2(type, x, a1, a2) \ - aux::sync_call_ret(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1, a2))) - -#define TORRENT_SYNC_CALL_RET3(type, x, a1, a2, a3) \ - aux::sync_call_ret(*m_impl, boost::function(boost::bind(&session_impl:: x, m_impl, a1, a2, a3))) - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif - using libtorrent::aux::session_impl; namespace libtorrent { + + template + void session_handle::async_call(Fun f, Args&&... a) const + { + m_impl->get_io_service().dispatch([=]() mutable + { (m_impl->*f)(a...); }); + } + + template + void session_handle::sync_call(Fun f, Args&&... a) const + { + // this is the flag to indicate the call has completed + // capture them by pointer to allow everything to be captured by value + // and simplify the capture expression + bool done = false; + + m_impl->get_io_service().dispatch([=,&done]() mutable + { + (m_impl->*f)(a...); + std::unique_lock l(m_impl->mut); + done = true; + m_impl->cond.notify_all(); + }); + + aux::torrent_wait(done, *m_impl); + } + + template + Ret session_handle::sync_call_ret(Fun f, Args&&... a) const + { + // this is the flag to indicate the call has completed + // capture them by pointer to allow everything to be captured by value + // and simplify the capture expression + bool done = false; + Ret r; + m_impl->get_io_service().dispatch([=,&r,&done]() mutable + { + r = (m_impl->*f)(a...); + std::unique_lock l(m_impl->mut); + done = true; + m_impl->cond.notify_all(); + }); + + aux::torrent_wait(done, *m_impl); + return r; + } + void session_handle::save_state(entry& e, boost::uint32_t flags) const { - TORRENT_SYNC_CALL2(save_state, &e, flags); + entry* ep = &e; + sync_call(&session_impl::save_state, ep, flags); } void session_handle::load_state(bdecode_node const& e @@ -111,35 +104,36 @@ namespace libtorrent { // this needs to be synchronized since the lifespan // of e is tied to the caller - TORRENT_SYNC_CALL2(load_state, &e, flags); + sync_call(&session_impl::load_state, &e, flags); } void session_handle::get_torrent_status(std::vector* ret , boost::function const& pred , boost::uint32_t flags) const { - TORRENT_SYNC_CALL3(get_torrent_status, ret, boost::ref(pred), flags); + auto predr = std::ref(pred); + sync_call(&session_impl::get_torrent_status, ret, predr, flags); } void session_handle::refresh_torrent_status(std::vector* ret , boost::uint32_t flags) const { - TORRENT_SYNC_CALL2(refresh_torrent_status, ret, flags); + sync_call(&session_impl::refresh_torrent_status, ret, flags); } void session_handle::post_torrent_updates(boost::uint32_t flags) { - TORRENT_ASYNC_CALL1(post_torrent_updates, flags); + async_call(&session_impl::post_torrent_updates, flags); } void session_handle::post_session_stats() { - TORRENT_ASYNC_CALL(post_session_stats); + async_call(&session_impl::post_session_stats); } void session_handle::post_dht_stats() { - TORRENT_ASYNC_CALL(post_dht_stats); + async_call(&session_impl::post_dht_stats); } io_service& session_handle::get_io_service() @@ -149,12 +143,12 @@ namespace libtorrent torrent_handle session_handle::find_torrent(sha1_hash const& info_hash) const { - return TORRENT_SYNC_CALL_RET1(torrent_handle, find_torrent_handle, info_hash); + return sync_call_ret(&session_impl::find_torrent_handle, info_hash); } std::vector session_handle::get_torrents() const { - return TORRENT_SYNC_CALL_RET(std::vector, get_torrents); + return sync_call_ret>(&session_impl::get_torrents); } #ifndef TORRENT_NO_DEPRECATE @@ -289,7 +283,8 @@ namespace libtorrent add_torrent_params const& p = params; #endif error_code ec; - torrent_handle r = TORRENT_SYNC_CALL_RET2(torrent_handle, add_torrent, p, boost::ref(ec)); + auto ecr = std::ref(ec); + torrent_handle r = sync_call_ret(&session_impl::add_torrent, p, ecr); if (ec) throw system_error(ec); return r; } @@ -306,7 +301,8 @@ namespace libtorrent #else add_torrent_params const& p = params; #endif - return TORRENT_SYNC_CALL_RET2(torrent_handle, add_torrent, p, boost::ref(ec)); + auto ecr = std::ref(ec); + return sync_call_ret(&session_impl::add_torrent, p, ecr); } void session_handle::async_add_torrent(add_torrent_params const& params) @@ -319,7 +315,7 @@ namespace libtorrent handle_backwards_compatible_resume_data(*p); #endif - TORRENT_ASYNC_CALL1(async_add_torrent, p); + async_call(&session_impl::async_add_torrent, p); } #ifndef BOOST_NO_EXCEPTIONS @@ -382,28 +378,28 @@ namespace libtorrent void session_handle::pause() { - TORRENT_ASYNC_CALL(pause); + async_call(&session_impl::pause); } void session_handle::resume() { - TORRENT_ASYNC_CALL(resume); + async_call(&session_impl::resume); } bool session_handle::is_paused() const { - return TORRENT_SYNC_CALL_RET(bool, is_paused); + return sync_call_ret(&session_impl::is_paused); } void session_handle::set_load_function(user_load_function_t fun) { - TORRENT_ASYNC_CALL1(set_load_function, fun); + async_call(&session_impl::set_load_function, fun); } #ifndef TORRENT_NO_DEPRECATE session_status session_handle::status() const { - return TORRENT_SYNC_CALL_RET(session_status, status); + return sync_call_ret(&session_impl::status); } void session_handle::get_cache_info(sha1_hash const& ih @@ -456,7 +452,7 @@ namespace libtorrent void session_handle::set_dht_settings(dht_settings const& settings) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(set_dht_settings, settings); + async_call(&session_impl::set_dht_settings, settings); #else TORRENT_UNUSED(settings); #endif @@ -465,7 +461,7 @@ namespace libtorrent dht_settings session_handle::get_dht_settings() const { #ifndef TORRENT_DISABLE_DHT - return TORRENT_SYNC_CALL_RET(dht_settings, get_dht_settings); + return sync_call_ret(&session_impl::get_dht_settings); #else return dht_settings(); #endif @@ -474,7 +470,7 @@ namespace libtorrent bool session_handle::is_dht_running() const { #ifndef TORRENT_DISABLE_DHT - return TORRENT_SYNC_CALL_RET(bool, is_dht_running); + return sync_call_ret(&session_impl::is_dht_running); #else return false; #endif @@ -483,7 +479,7 @@ namespace libtorrent void session_handle::set_dht_storage(dht::dht_storage_constructor_type sc) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(set_dht_storage, sc); + async_call(&session_impl::set_dht_storage, sc); #else TORRENT_UNUSED(sc); #endif @@ -492,7 +488,7 @@ namespace libtorrent void session_handle::add_dht_node(std::pair const& node) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(add_dht_node_name, node); + async_call(&session_impl::add_dht_node_name, node); #else TORRENT_UNUSED(node); #endif @@ -501,7 +497,7 @@ namespace libtorrent void session_handle::add_dht_router(std::pair const& node) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(add_dht_router, node); + async_call(&session_impl::add_dht_router, node); #else TORRENT_UNUSED(node); #endif @@ -510,7 +506,7 @@ namespace libtorrent void session_handle::dht_get_item(sha1_hash const& target) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(dht_get_immutable_item, target); + async_call(&session_impl::dht_get_immutable_item, target); #else TORRENT_UNUSED(target); #endif @@ -520,7 +516,7 @@ namespace libtorrent , std::string salt) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL2(dht_get_mutable_item, key, salt); + async_call(&session_impl::dht_get_mutable_item, key, salt); #else TORRENT_UNUSED(key); TORRENT_UNUSED(salt); @@ -534,7 +530,7 @@ namespace libtorrent sha1_hash ret = hasher(&buf[0], int(buf.size())).final(); #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL2(dht_put_immutable_item, data, ret); + async_call(&session_impl::dht_put_immutable_item, data, ret); #endif return ret; } @@ -545,7 +541,7 @@ namespace libtorrent , std::string salt) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL3(dht_put_mutable_item, key, cb, salt); + async_call(&session_impl::dht_put_mutable_item, key, cb, salt); #else TORRENT_UNUSED(key); TORRENT_UNUSED(cb); @@ -556,7 +552,7 @@ namespace libtorrent void session_handle::dht_get_peers(sha1_hash const& info_hash) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(dht_get_peers, info_hash); + async_call(&session_impl::dht_get_peers, info_hash); #else TORRENT_UNUSED(info_hash); #endif @@ -565,7 +561,7 @@ namespace libtorrent void session_handle::dht_announce(sha1_hash const& info_hash, int port, int flags) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL3(dht_announce, info_hash, port, flags); + async_call(&session_impl::dht_announce, info_hash, port, flags); #else TORRENT_UNUSED(info_hash); TORRENT_UNUSED(port); @@ -576,7 +572,8 @@ namespace libtorrent void session_handle::dht_direct_request(udp::endpoint ep, entry const& e, void* userdata) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL3(dht_direct_request, ep, e, userdata); + entry copy = e; + async_call(&session_impl::dht_direct_request, ep, copy, userdata); #else TORRENT_UNUSED(ep); TORRENT_UNUSED(e); @@ -588,7 +585,7 @@ namespace libtorrent entry session_handle::dht_state() const { #ifndef TORRENT_DISABLE_DHT - return TORRENT_SYNC_CALL_RET(entry, dht_state); + return sync_call_ret(&session_impl::dht_state); #else return entry(); #endif @@ -597,7 +594,7 @@ namespace libtorrent void session_handle::start_dht(entry const& startup_state) { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL1(start_dht_deprecated, startup_state); + async_call(&session_impl::start_dht_deprecated, startup_state); #else TORRENT_UNUSED(startup_state); #endif @@ -607,7 +604,7 @@ namespace libtorrent void session_handle::add_extension(boost::function(torrent_handle const&, void*)> ext) { #ifndef TORRENT_DISABLE_EXTENSIONS - TORRENT_ASYNC_CALL1(add_extension, ext); + async_call(&session_impl::add_extension, ext); #else TORRENT_UNUSED(ext); #endif @@ -616,7 +613,7 @@ namespace libtorrent void session_handle::add_extension(boost::shared_ptr ext) { #ifndef TORRENT_DISABLE_EXTENSIONS - TORRENT_ASYNC_CALL1(add_ses_extension, ext); + async_call(&session_impl::add_ses_extension, ext); #else TORRENT_UNUSED(ext); #endif @@ -651,13 +648,14 @@ namespace libtorrent #ifndef BOOST_NO_EXCEPTIONS if (ret != 0) throw system_error(ec); #endif - TORRENT_SYNC_CALL2(load_state, &e, flags); + sync_call(&session_impl::load_state, &e, flags); } entry session_handle::state() const { entry ret; - TORRENT_SYNC_CALL2(save_state, &ret, 0xffffffff); + auto retp = &ret; + sync_call(&session_impl::save_state, retp, 0xffffffff); return ret; } @@ -677,24 +675,24 @@ namespace libtorrent #ifndef BOOST_NO_EXCEPTIONS if (ret != 0) throw system_error(ec); #endif - TORRENT_SYNC_CALL2(load_state, &e, flags); + sync_call(&session_impl::load_state, &e, flags); } #endif // TORRENT_NO_DEPRECATE void session_handle::set_ip_filter(ip_filter const& f) { boost::shared_ptr copy = boost::make_shared(f); - TORRENT_ASYNC_CALL1(set_ip_filter, copy); + async_call(&session_impl::set_ip_filter, copy); } ip_filter session_handle::get_ip_filter() const { - return TORRENT_SYNC_CALL_RET(ip_filter, get_ip_filter); + return sync_call_ret(&session_impl::get_ip_filter); } void session_handle::set_port_filter(port_filter const& f) { - TORRENT_ASYNC_CALL1(set_port_filter, f); + async_call(&session_impl::set_port_filter, f); } #ifndef TORRENT_NO_DEPRECATE @@ -708,57 +706,57 @@ namespace libtorrent peer_id session_handle::id() const { - return TORRENT_SYNC_CALL_RET(peer_id, get_peer_id); + return sync_call_ret(&session_impl::get_peer_id); } void session_handle::set_key(int key) { - TORRENT_ASYNC_CALL1(set_key, key); + async_call(&session_impl::set_key, key); } unsigned short session_handle::listen_port() const { - return TORRENT_SYNC_CALL_RET(unsigned short, listen_port); + return sync_call_ret(&session_impl::listen_port); } unsigned short session_handle::ssl_listen_port() const { - return TORRENT_SYNC_CALL_RET(unsigned short, ssl_listen_port); + return sync_call_ret(&session_impl::ssl_listen_port); } bool session_handle::is_listening() const { - return TORRENT_SYNC_CALL_RET(bool, is_listening); + return sync_call_ret(&session_impl::is_listening); } void session_handle::set_peer_class_filter(ip_filter const& f) { - TORRENT_ASYNC_CALL1(set_peer_class_filter, f); + async_call(&session_impl::set_peer_class_filter, f); } void session_handle::set_peer_class_type_filter(peer_class_type_filter const& f) { - TORRENT_ASYNC_CALL1(set_peer_class_type_filter, f); + async_call(&session_impl::set_peer_class_type_filter, f); } int session_handle::create_peer_class(char const* name) { - return TORRENT_SYNC_CALL_RET1(int, create_peer_class, name); + return sync_call_ret(&session_impl::create_peer_class, name); } void session_handle::delete_peer_class(int cid) { - TORRENT_ASYNC_CALL1(delete_peer_class, cid); + async_call(&session_impl::delete_peer_class, cid); } peer_class_info session_handle::get_peer_class(int cid) { - return TORRENT_SYNC_CALL_RET1(peer_class_info, get_peer_class, cid); + return sync_call_ret(&session_impl::get_peer_class, cid); } void session_handle::set_peer_class(int cid, peer_class_info const& pci) { - TORRENT_ASYNC_CALL2(set_peer_class, cid, pci); + async_call(&session_impl::set_peer_class, cid, pci); } #ifndef TORRENT_NO_DEPRECATE @@ -797,18 +795,18 @@ namespace libtorrent #else throw_invalid_handle(); #endif - TORRENT_ASYNC_CALL2(remove_torrent, h, options); + async_call(&session_impl::remove_torrent, h, options); } #ifndef TORRENT_NO_DEPRECATE void session_handle::set_settings(session_settings const& s) { - TORRENT_ASYNC_CALL1(set_settings, s); + async_call(&session_impl::set_settings, s); } session_settings session_handle::settings() const { - return TORRENT_SYNC_CALL_RET(session_settings, deprecated_settings); + return sync_call_ret(&session_impl::deprecated_settings); } void session_handle::set_pe_settings(pe_settings const& r) @@ -848,12 +846,12 @@ namespace libtorrent <= settings_pack::pe_both); boost::shared_ptr copy = boost::make_shared(s); - TORRENT_ASYNC_CALL1(apply_settings_pack, copy); + async_call(&session_impl::apply_settings_pack, copy); } settings_pack session_handle::get_settings() const { - return TORRENT_SYNC_CALL_RET(settings_pack, get_settings); + return sync_call_ret(&session_impl::get_settings); } #ifndef TORRENT_NO_DEPRECATE @@ -897,12 +895,12 @@ namespace libtorrent int session_handle::num_uploads() const { - return TORRENT_SYNC_CALL_RET(int, num_uploads); + return sync_call_ret(&session_impl::num_uploads); } int session_handle::num_connections() const { - return TORRENT_SYNC_CALL_RET(int, num_connections); + return sync_call_ret(&session_impl::num_connections); } void session_handle::set_peer_proxy(proxy_settings const& s) @@ -947,66 +945,66 @@ namespace libtorrent int session_handle::upload_rate_limit() const { - return TORRENT_SYNC_CALL_RET(int, upload_rate_limit); + return sync_call_ret(&session_impl::upload_rate_limit_depr); } int session_handle::download_rate_limit() const { - return TORRENT_SYNC_CALL_RET(int, download_rate_limit); + return sync_call_ret(&session_impl::download_rate_limit_depr); } int session_handle::local_upload_rate_limit() const { - return TORRENT_SYNC_CALL_RET(int, local_upload_rate_limit); + return sync_call_ret(&session_impl::local_upload_rate_limit); } int session_handle::local_download_rate_limit() const { - return TORRENT_SYNC_CALL_RET(int, local_download_rate_limit); + return sync_call_ret(&session_impl::local_download_rate_limit); } int session_handle::max_half_open_connections() const { return 8; } void session_handle::set_local_upload_rate_limit(int bytes_per_second) { - TORRENT_ASYNC_CALL1(set_local_upload_rate_limit, bytes_per_second); + async_call(&session_impl::set_local_upload_rate_limit, bytes_per_second); } void session_handle::set_local_download_rate_limit(int bytes_per_second) { - TORRENT_ASYNC_CALL1(set_local_download_rate_limit, bytes_per_second); + async_call(&session_impl::set_local_download_rate_limit, bytes_per_second); } void session_handle::set_upload_rate_limit(int bytes_per_second) { - TORRENT_ASYNC_CALL1(set_upload_rate_limit, bytes_per_second); + async_call(&session_impl::set_upload_rate_limit_depr, bytes_per_second); } void session_handle::set_download_rate_limit(int bytes_per_second) { - TORRENT_ASYNC_CALL1(set_download_rate_limit, bytes_per_second); + async_call(&session_impl::set_download_rate_limit_depr, bytes_per_second); } void session_handle::set_max_connections(int limit) { - TORRENT_ASYNC_CALL1(set_max_connections, limit); + async_call(&session_impl::set_max_connections, limit); } void session_handle::set_max_uploads(int limit) { - TORRENT_ASYNC_CALL1(set_max_uploads, limit); + async_call(&session_impl::set_max_uploads, limit); } void session_handle::set_max_half_open_connections(int) {} int session_handle::max_uploads() const { - return TORRENT_SYNC_CALL_RET(int, max_uploads); + return sync_call_ret(&session_impl::max_uploads); } int session_handle::max_connections() const { - return TORRENT_SYNC_CALL_RET(int, max_connections); + return sync_call_ret(&session_impl::max_connections); } #endif // TORRENT_NO_DEPRECATE @@ -1051,7 +1049,7 @@ namespace libtorrent size_t session_handle::set_alert_queue_size_limit(size_t queue_size_limit_) { - return TORRENT_SYNC_CALL_RET1(size_t, set_alert_queue_size_limit, queue_size_limit_); + return sync_call_ret(&session_impl::set_alert_queue_size_limit, queue_size_limit_); } void session_handle::set_alert_mask(boost::uint32_t m) @@ -1111,12 +1109,12 @@ namespace libtorrent int session_handle::add_port_mapping(session::protocol_type t, int external_port, int local_port) { - return TORRENT_SYNC_CALL_RET3(int, add_port_mapping, int(t), external_port, local_port); + return sync_call_ret(&session_impl::add_port_mapping, int(t), external_port, local_port); } void session_handle::delete_port_mapping(int handle) { - TORRENT_ASYNC_CALL1(delete_port_mapping, handle); + async_call(&session_impl::delete_port_mapping, handle); } } // namespace libtorrent diff --git a/src/session_impl.cpp b/src/session_impl.cpp index 7c666a60b..f7acbf611 100644 --- a/src/session_impl.cpp +++ b/src/session_impl.cpp @@ -5925,14 +5925,14 @@ namespace aux { apply_settings_pack_impl(p); } - void session_impl::set_download_rate_limit(int bytes_per_second) + void session_impl::set_download_rate_limit_depr(int bytes_per_second) { settings_pack p; p.set_int(settings_pack::download_rate_limit, bytes_per_second); apply_settings_pack_impl(p); } - void session_impl::set_upload_rate_limit(int bytes_per_second) + void session_impl::set_upload_rate_limit_depr(int bytes_per_second) { settings_pack p; p.set_int(settings_pack::upload_rate_limit, bytes_per_second); @@ -5963,12 +5963,12 @@ namespace aux { return download_rate_limit(m_local_peer_class); } - int session_impl::upload_rate_limit() const + int session_impl::upload_rate_limit_depr() const { return upload_rate_limit(m_global_class); } - int session_impl::download_rate_limit() const + int session_impl::download_rate_limit_depr() const { return download_rate_limit(m_global_class); } diff --git a/src/torrent.cpp b/src/torrent.cpp index 9b14088fa..827028173 100644 --- a/src/torrent.cpp +++ b/src/torrent.cpp @@ -1434,7 +1434,7 @@ namespace libtorrent m_extensions.erase(i); } - void torrent::add_extension(boost::function(torrent_handle const&, void*)> const& ext + void torrent::add_extension_fun(boost::function(torrent_handle const&, void*)> const& ext , void* userdata) { boost::shared_ptr tp(ext(get_handle(), userdata)); @@ -4773,7 +4773,7 @@ namespace libtorrent m_state_subscription = false; } - void torrent::super_seeding(bool on) + void torrent::set_super_seeding(bool on) { if (on == m_super_seeding) return; @@ -5948,7 +5948,7 @@ namespace libtorrent update_want_tick(); } - void torrent::remove_web_seed(std::list::iterator web) + void torrent::remove_web_seed_iter(std::list::iterator web) { if (web->resolving) { @@ -6014,7 +6014,7 @@ namespace libtorrent , web->url, ec); } // never try it again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6029,7 +6029,7 @@ namespace libtorrent , error_code(libtorrent::errors::peer_banned, get_libtorrent_category())); } // never try it again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6044,7 +6044,7 @@ namespace libtorrent m_ses.alerts().emplace_alert(get_handle(), web->url, errors::unsupported_url_protocol); } // never try it again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6056,7 +6056,7 @@ namespace libtorrent , errors::invalid_hostname); } // never try it again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6068,7 +6068,7 @@ namespace libtorrent , errors::invalid_port); } // never try it again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6080,7 +6080,7 @@ namespace libtorrent , web->url, errors::port_blocked); } // never try it again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6146,7 +6146,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING debug_log("removed web seed"); #endif - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6162,7 +6162,7 @@ namespace libtorrent // the name lookup failed for the http host. Don't try // this host again - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6189,7 +6189,7 @@ namespace libtorrent m_ses.alerts().emplace_alert(get_handle() , web->url, ec); } - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -6226,7 +6226,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING debug_log("removed web seed"); #endif - remove_web_seed(web); + remove_web_seed_iter(web); return; } @@ -9146,17 +9146,10 @@ namespace libtorrent // add or remove a url that will be attempted for // finding the file(s) in this torrent. - void torrent::add_web_seed(std::string const& url, web_seed_entry::type_t type) - { - web_seed_t ent(url, type); - // don't add duplicates - if (std::find(m_web_seeds.begin(), m_web_seeds.end(), ent) != m_web_seeds.end()) return; - m_web_seeds.push_back(ent); - set_need_save_resume(); - } - - void torrent::add_web_seed(std::string const& url, web_seed_entry::type_t type - , std::string const& auth, web_seed_entry::headers_t const& extra_headers) + void torrent::add_web_seed(std::string const& url + , web_seed_entry::type_t type + , std::string const& auth + , web_seed_entry::headers_t const& extra_headers) { web_seed_t ent(url, type, auth, extra_headers); // don't add duplicates @@ -10444,7 +10437,7 @@ namespace libtorrent , (boost::bind(&web_seed_t::url, _1) == url && boost::bind(&web_seed_t::type, _1) == type)); - if (i != m_web_seeds.end()) remove_web_seed(i); + if (i != m_web_seeds.end()) remove_web_seed_iter(i); } void torrent::disconnect_web_seed(peer_connection* p) @@ -10465,7 +10458,7 @@ namespace libtorrent i->peer_info.connection = 0; } - void torrent::remove_web_seed(peer_connection* p, error_code const& ec + void torrent::remove_web_seed_conn(peer_connection* p, error_code const& ec , operation_t op, int error) { std::list::iterator i = std::find_if(m_web_seeds.begin() @@ -10485,7 +10478,7 @@ namespace libtorrent peer->disconnect(ec, op, error); peer->set_peer_info(0); } - remove_web_seed(i); + remove_web_seed_iter(i); } void torrent::retry_web_seed(peer_connection* p, int retry) @@ -10791,7 +10784,7 @@ namespace libtorrent } #if !TORRENT_NO_FPU - void torrent::file_progress(std::vector& fp) + void torrent::file_progress_float(std::vector& fp) { TORRENT_ASSERT(is_single_thread()); if (!valid_metadata()) diff --git a/src/torrent_handle.cpp b/src/torrent_handle.cpp index 83ea41224..35a600b5c 100644 --- a/src/torrent_handle.cpp +++ b/src/torrent_handle.cpp @@ -30,19 +30,11 @@ POSSIBILITY OF SUCH DAMAGE. */ -#include "libtorrent/aux_/disable_warnings_push.hpp" - #include #include #include #include #include -#include - -#include -#include - -#include "libtorrent/aux_/disable_warnings_pop.hpp" #include "libtorrent/peer_id.hpp" #include "libtorrent/bt_peer_connection.hpp" @@ -62,85 +54,6 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/peer_info.hpp" // for peer_list_entry #endif -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-macros" -#endif - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunused-macros" -#endif - -#define TORRENT_ASYNC_CALL(x) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (!t) return; \ - session_impl& ses = static_cast(t->session()); \ - ses.get_io_service().dispatch(boost::bind(&torrent:: x, t)) - -#define TORRENT_ASYNC_CALL1(x, a1) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (!t) return; \ - session_impl& ses = static_cast(t->session()); \ - ses.get_io_service().dispatch(boost::bind(&torrent:: x, t, a1)) - -#define TORRENT_ASYNC_CALL2(x, a1, a2) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (!t) return; \ - session_impl& ses = static_cast(t->session()); \ - ses.get_io_service().dispatch(boost::bind(&torrent:: x, t, a1, a2)) - -#define TORRENT_ASYNC_CALL3(x, a1, a2, a3) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (!t) return; \ - session_impl& ses = static_cast(t->session()); \ - ses.get_io_service().dispatch(boost::bind(&torrent:: x, t, a1, a2, a3)) - -#define TORRENT_ASYNC_CALL4(x, a1, a2, a3, a4) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (!t) return; \ - session_impl& ses = static_cast(t->session()); \ - ses.get_io_service().dispatch(boost::bind(&torrent:: x, t, a1, a2, a3, a4)) - -#define TORRENT_SYNC_CALL(x) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (t) aux::sync_call_handle(t, boost::bind(&torrent:: x, t)); - -#define TORRENT_SYNC_CALL1(x, a1) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (t) aux::sync_call_handle(t, boost::bind(&torrent:: x, t, a1)); - -#define TORRENT_SYNC_CALL2(x, a1, a2) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (t) aux::sync_call_handle(t, boost::bind(&torrent:: x, t, a1, a2)); - -#define TORRENT_SYNC_CALL3(x, a1, a2, a3) \ - boost::shared_ptr t = m_torrent.lock(); \ - if (t) aux::sync_call_handle(t, boost::bind(&torrent:: x, t, a1, a2, a3)); - -#define TORRENT_SYNC_CALL_RET(type, def, x) \ - boost::shared_ptr t = m_torrent.lock(); \ - type r = def; \ - if (t) aux::sync_call_ret_handle(t, r, boost::function(boost::bind(&torrent:: x, t))); - -#define TORRENT_SYNC_CALL_RET1(type, def, x, a1) \ - boost::shared_ptr t = m_torrent.lock(); \ - type r = def; \ - if (t) aux::sync_call_ret_handle(t, r, boost::function(boost::bind(&torrent:: x, t, a1))); - -#define TORRENT_SYNC_CALL_RET2(type, def, x, a1, a2) \ - boost::shared_ptr t = m_torrent.lock(); \ - type r = def; \ - if (t) aux::sync_call_ret_handle(t, r, boost::function(boost::bind(&torrent:: x, t, a1, a2))); - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif - using libtorrent::aux::session_impl; namespace libtorrent @@ -153,6 +66,63 @@ namespace libtorrent } #endif + template + void torrent_handle::async_call(Fun f, Args&&... a) const + { + boost::shared_ptr t = m_torrent.lock(); + TORRENT_ASSERT_PRECOND(t); + if (!t) return; + session_impl& ses = static_cast(t->session()); + ses.get_io_service().dispatch([=] () { (t.get()->*f)(a...); } ); + } + + template + void torrent_handle::sync_call(Fun f, Args&&... a) const + { + boost::shared_ptr t = m_torrent.lock(); + TORRENT_ASSERT_PRECOND(t); + if (!t) return; + session_impl& ses = static_cast(t->session()); + + // this is the flag to indicate the call has completed + bool done = false; + + ses.get_io_service().dispatch([=,&done,&ses] () + { + (t.get()->*f)(a...); + std::unique_lock l(ses.mut); + done = true; + ses.cond.notify_all(); + } ); + + aux::torrent_wait(done, ses); + } + + template + Ret torrent_handle::sync_call_ret(Ret def, Fun f, Args&&... a) const + { + boost::shared_ptr t = m_torrent.lock(); + TORRENT_ASSERT_PRECOND(t); + Ret r = def; + if (!t) return r; + session_impl& ses = static_cast(t->session()); + + // this is the flag to indicate the call has completed + bool done = false; + + ses.get_io_service().dispatch([=,&r,&done,&ses] () + { + r = (t.get()->*f)(a...); + std::unique_lock l(ses.mut); + done = true; + ses.cond.notify_all(); + } ); + + aux::torrent_wait(done, ses); + + return r; + } + sha1_hash torrent_handle::info_hash() const { boost::shared_ptr t = m_torrent.lock(); @@ -163,56 +133,52 @@ namespace libtorrent int torrent_handle::max_uploads() const { - TORRENT_SYNC_CALL_RET(int, 0, max_uploads); - return r; + return sync_call_ret(0, &torrent::max_uploads); } void torrent_handle::set_max_uploads(int max_uploads) const { TORRENT_ASSERT_PRECOND(max_uploads >= 2 || max_uploads == -1); - TORRENT_ASYNC_CALL2(set_max_uploads, max_uploads, true); + async_call(&torrent::set_max_uploads, max_uploads, true); } int torrent_handle::max_connections() const { - TORRENT_SYNC_CALL_RET(int, 0, max_connections); - return r; + return sync_call_ret(0, &torrent::max_connections); } void torrent_handle::set_max_connections(int max_connections) const { TORRENT_ASSERT_PRECOND(max_connections >= 2 || max_connections == -1); - TORRENT_ASYNC_CALL2(set_max_connections, max_connections, true); + async_call(&torrent::set_max_connections, max_connections, true); } void torrent_handle::set_upload_limit(int limit) const { TORRENT_ASSERT_PRECOND(limit >= -1); - TORRENT_ASYNC_CALL1(set_upload_limit, limit); + async_call(&torrent::set_upload_limit, limit); } int torrent_handle::upload_limit() const { - TORRENT_SYNC_CALL_RET(int, 0, upload_limit); - return r; + return sync_call_ret(0, &torrent::upload_limit); } void torrent_handle::set_download_limit(int limit) const { TORRENT_ASSERT_PRECOND(limit >= -1); - TORRENT_ASYNC_CALL1(set_download_limit, limit); + async_call(&torrent::set_download_limit, limit); } int torrent_handle::download_limit() const { - TORRENT_SYNC_CALL_RET(int, 0, download_limit); - return r; + return sync_call_ret(0, &torrent::download_limit); } void torrent_handle::move_storage( std::string const& save_path, int flags) const { - TORRENT_ASYNC_CALL2(move_storage, save_path, flags); + async_call(&torrent::move_storage, save_path, flags); } #if TORRENT_USE_WSTRING @@ -222,21 +188,21 @@ namespace libtorrent { std::string utf8; wchar_utf8(save_path, utf8); - TORRENT_ASYNC_CALL2(move_storage, utf8, flags); + async_call(&torrent::move_storage, utf8, flags); } void torrent_handle::rename_file(int index, std::wstring const& new_name) const { std::string utf8; wchar_utf8(new_name, utf8); - TORRENT_ASYNC_CALL2(rename_file, index, utf8); + async_call(&torrent::rename_file, index, utf8); } #endif // TORRENT_NO_DEPRECATE #endif // TORRENT_USE_WSTRING void torrent_handle::rename_file(int index, std::string const& new_name) const { - TORRENT_ASYNC_CALL2(rename_file, index, new_name); + async_call(&torrent::rename_file, index, new_name); } void torrent_handle::add_extension( @@ -244,7 +210,7 @@ namespace libtorrent , void* userdata) { #ifndef TORRENT_DISABLE_EXTENSIONS - TORRENT_ASYNC_CALL2(add_extension, ext, userdata); + async_call(&torrent::add_extension_fun, ext, userdata); #else TORRENT_UNUSED(ext); TORRENT_UNUSED(userdata); @@ -253,38 +219,37 @@ namespace libtorrent bool torrent_handle::set_metadata(char const* metadata, int size) const { - TORRENT_SYNC_CALL_RET2(bool, false, set_metadata, metadata, size); - return r; + return sync_call_ret(false, &torrent::set_metadata, metadata, size); } void torrent_handle::pause(int flags) const { - TORRENT_ASYNC_CALL1(pause, bool(flags & graceful_pause)); + async_call(&torrent::pause, bool(flags & graceful_pause)); } void torrent_handle::stop_when_ready(bool b) const { - TORRENT_ASYNC_CALL1(stop_when_ready, b); + async_call(&torrent::stop_when_ready, b); } void torrent_handle::apply_ip_filter(bool b) const { - TORRENT_ASYNC_CALL1(set_apply_ip_filter, b); + async_call(&torrent::set_apply_ip_filter, b); } void torrent_handle::set_share_mode(bool b) const { - TORRENT_ASYNC_CALL1(set_share_mode, b); + async_call(&torrent::set_share_mode, b); } void torrent_handle::set_upload_mode(bool b) const { - TORRENT_ASYNC_CALL1(set_upload_mode, b); + async_call(&torrent::set_upload_mode, b); } void torrent_handle::flush_cache() const { - TORRENT_ASYNC_CALL(flush_cache); + async_call(&torrent::flush_cache); } void torrent_handle::set_ssl_certificate( @@ -294,7 +259,7 @@ namespace libtorrent , std::string const& passphrase) { #ifdef TORRENT_USE_OPENSSL - TORRENT_ASYNC_CALL4(set_ssl_cert, certificate, private_key, dh_params, passphrase); + async_call(&torrent::set_ssl_cert, certificate, private_key, dh_params, passphrase); #else TORRENT_UNUSED(certificate); TORRENT_UNUSED(private_key); @@ -309,7 +274,7 @@ namespace libtorrent , std::string const& dh_params) { #ifdef TORRENT_USE_OPENSSL - TORRENT_ASYNC_CALL3(set_ssl_cert_buffer, certificate, private_key, dh_params); + async_call(&torrent::set_ssl_cert_buffer, certificate, private_key, dh_params); #else TORRENT_UNUSED(certificate); TORRENT_UNUSED(private_key); @@ -319,149 +284,148 @@ namespace libtorrent void torrent_handle::save_resume_data(int f) const { - TORRENT_ASYNC_CALL1(save_resume_data, f); + async_call(&torrent::save_resume_data, f); } bool torrent_handle::need_save_resume_data() const { - TORRENT_SYNC_CALL_RET(bool, false, need_save_resume_data); - return r; + return sync_call_ret(false, &torrent::need_save_resume_data); } void torrent_handle::force_recheck() const { - TORRENT_ASYNC_CALL(force_recheck); + async_call(&torrent::force_recheck); } void torrent_handle::resume() const { - TORRENT_ASYNC_CALL(resume); + async_call(&torrent::resume); } void torrent_handle::auto_managed(bool m) const { - TORRENT_ASYNC_CALL1(auto_managed, m); + async_call(&torrent::auto_managed, m); } void torrent_handle::set_priority(int p) const { - TORRENT_ASYNC_CALL1(set_priority, p); + async_call(&torrent::set_priority, p); } int torrent_handle::queue_position() const { - TORRENT_SYNC_CALL_RET(int, -1, queue_position); - return r; + return sync_call_ret(-1, &torrent::queue_position); } void torrent_handle::queue_position_up() const { - TORRENT_ASYNC_CALL(queue_up); + async_call(&torrent::queue_up); } void torrent_handle::queue_position_down() const { - TORRENT_ASYNC_CALL(queue_down); + async_call(&torrent::queue_down); } void torrent_handle::queue_position_top() const { - TORRENT_ASYNC_CALL1(set_queue_position, 0); + async_call(&torrent::set_queue_position, 0); } void torrent_handle::queue_position_bottom() const { - TORRENT_ASYNC_CALL1(set_queue_position, INT_MAX); + async_call(&torrent::set_queue_position, INT_MAX); } void torrent_handle::clear_error() const { - TORRENT_ASYNC_CALL(clear_error); + async_call(&torrent::clear_error); } #ifndef TORRENT_NO_DEPRECATE void torrent_handle::set_tracker_login(std::string const& name , std::string const& password) const { - TORRENT_ASYNC_CALL2(set_tracker_login, name, password); + async_call(&torrent::set_tracker_login, name, password); } #endif void torrent_handle::file_progress(std::vector& progress, int flags) const { - TORRENT_SYNC_CALL2(file_progress, boost::ref(progress), flags); + sync_call(&torrent::file_progress, std::ref(progress), flags); } torrent_status torrent_handle::status(boost::uint32_t flags) const { torrent_status st; - TORRENT_SYNC_CALL2(status, &st, flags); + sync_call(&torrent::status, &st, flags); return st; } void torrent_handle::set_pinned(bool p) const { - TORRENT_ASYNC_CALL1(set_pinned, p); + async_call(&torrent::set_pinned, p); } void torrent_handle::set_sequential_download(bool sd) const { - TORRENT_ASYNC_CALL1(set_sequential_download, sd); + async_call(&torrent::set_sequential_download, sd); } void torrent_handle::piece_availability(std::vector& avail) const { - TORRENT_SYNC_CALL1(piece_availability, boost::ref(avail)); + auto availr = std::ref(avail); + sync_call(&torrent::piece_availability, availr); } void torrent_handle::piece_priority(int index, int priority) const { - TORRENT_ASYNC_CALL2(set_piece_priority, index, priority); + async_call(&torrent::set_piece_priority, index, priority); } int torrent_handle::piece_priority(int index) const { - TORRENT_SYNC_CALL_RET1(int, 0, piece_priority, index); - return r; + return sync_call_ret(0, &torrent::piece_priority, index); } void torrent_handle::prioritize_pieces(std::vector const& pieces) const { - TORRENT_ASYNC_CALL1(prioritize_pieces, pieces); + async_call(&torrent::prioritize_pieces, pieces); } void torrent_handle::prioritize_pieces(std::vector > const& pieces) const { - TORRENT_ASYNC_CALL1(prioritize_piece_list, pieces); + async_call(&torrent::prioritize_piece_list, pieces); } std::vector torrent_handle::piece_priorities() const { std::vector ret; - TORRENT_SYNC_CALL1(piece_priorities, &ret); + auto retp = &ret; + sync_call(&torrent::piece_priorities, retp); return ret; } void torrent_handle::file_priority(int index, int priority) const { - TORRENT_ASYNC_CALL2(set_file_priority, index, priority); + async_call(&torrent::set_file_priority, index, priority); } int torrent_handle::file_priority(int index) const { - TORRENT_SYNC_CALL_RET1(int, 0, file_priority, index); - return r; + return sync_call_ret(0, &torrent::file_priority, index); } void torrent_handle::prioritize_files(std::vector const& files) const { - TORRENT_ASYNC_CALL1(prioritize_files, files); + async_call(&torrent::prioritize_files, files); } std::vector torrent_handle::file_priorities() const { std::vector ret; - TORRENT_SYNC_CALL1(file_priorities, &ret); + auto retp = &ret; + sync_call(&torrent::file_priorities, retp); return ret; } @@ -475,84 +439,78 @@ namespace libtorrent void torrent_handle::set_ratio(float) const {} void torrent_handle::use_interface(const char* net_interface) const { - TORRENT_ASYNC_CALL1(use_interface, std::string(net_interface)); + async_call(&torrent::use_interface, std::string(net_interface)); } #if !TORRENT_NO_FPU void torrent_handle::file_progress(std::vector& progress) const { - TORRENT_SYNC_CALL1(file_progress, boost::ref(progress)); + sync_call(&torrent::file_progress_float, std::ref(progress)); } #endif bool torrent_handle::is_seed() const { - TORRENT_SYNC_CALL_RET(bool, false, is_seed); - return r; + return sync_call_ret(false, &torrent::is_seed); } bool torrent_handle::is_finished() const { - TORRENT_SYNC_CALL_RET(bool, false, is_finished); - return r; + return sync_call_ret(false, &torrent::is_finished); } bool torrent_handle::is_paused() const { - TORRENT_SYNC_CALL_RET(bool, false, is_torrent_paused); - return r; + return sync_call_ret(false, &torrent::is_torrent_paused); } bool torrent_handle::is_sequential_download() const { - TORRENT_SYNC_CALL_RET(bool, false, is_sequential_download); - return r; + return sync_call_ret(false, &torrent::is_sequential_download); } bool torrent_handle::is_auto_managed() const { - TORRENT_SYNC_CALL_RET(bool, false, is_auto_managed); - return r; + return sync_call_ret(false, &torrent::is_auto_managed); } bool torrent_handle::has_metadata() const { - TORRENT_SYNC_CALL_RET(bool, false, valid_metadata); - return r; + return sync_call_ret(false, &torrent::valid_metadata); } void torrent_handle::filter_piece(int index, bool filter) const { - TORRENT_ASYNC_CALL2(filter_piece, index, filter); + async_call(&torrent::filter_piece, index, filter); } void torrent_handle::filter_pieces(std::vector const& pieces) const { - TORRENT_ASYNC_CALL1(filter_pieces, pieces); + async_call(&torrent::filter_pieces, pieces); } bool torrent_handle::is_piece_filtered(int index) const { - TORRENT_SYNC_CALL_RET1(bool, false, is_piece_filtered, index); - return r; + return sync_call_ret(false, &torrent::is_piece_filtered, index); } std::vector torrent_handle::filtered_pieces() const { std::vector ret; - TORRENT_SYNC_CALL1(filtered_pieces, ret); + auto retr = std::ref(ret); + sync_call(&torrent::filtered_pieces, retr); return ret; } void torrent_handle::filter_files(std::vector const& files) const { - TORRENT_ASYNC_CALL1(filter_files, files); + auto filesr= std::ref(files); + async_call(&torrent::filter_files, filesr); } bool torrent_handle::super_seeding() const { - TORRENT_SYNC_CALL_RET(bool, false, super_seeding); - return r; + return sync_call_ret(false, &torrent::super_seeding); } // ============ end deprecation =============== @@ -561,75 +519,72 @@ namespace libtorrent std::vector torrent_handle::trackers() const { static const std::vector empty; - TORRENT_SYNC_CALL_RET(std::vector, empty, trackers); - return r; + return sync_call_ret>(empty, &torrent::trackers); } void torrent_handle::add_url_seed(std::string const& url) const { - TORRENT_ASYNC_CALL2(add_web_seed, url, web_seed_entry::url_seed); + async_call(&torrent::add_web_seed, url, web_seed_entry::url_seed + , std::string(), web_seed_entry::headers_t()); } void torrent_handle::remove_url_seed(std::string const& url) const { - TORRENT_ASYNC_CALL2(remove_web_seed, url, web_seed_entry::url_seed); + async_call(&torrent::remove_web_seed, url, web_seed_entry::url_seed); } std::set torrent_handle::url_seeds() const { static const std::set empty; - TORRENT_SYNC_CALL_RET1(std::set, empty, web_seeds, web_seed_entry::url_seed); - return r; + return sync_call_ret>(empty, &torrent::web_seeds, web_seed_entry::url_seed); } void torrent_handle::add_http_seed(std::string const& url) const { - TORRENT_ASYNC_CALL2(add_web_seed, url, web_seed_entry::http_seed); + async_call(&torrent::add_web_seed, url, web_seed_entry::http_seed + , std::string(), web_seed_entry::headers_t()); } void torrent_handle::remove_http_seed(std::string const& url) const { - TORRENT_ASYNC_CALL2(remove_web_seed, url, web_seed_entry::http_seed); + async_call(&torrent::remove_web_seed, url, web_seed_entry::http_seed); } std::set torrent_handle::http_seeds() const { static const std::set empty; - TORRENT_SYNC_CALL_RET1(std::set, empty, web_seeds, web_seed_entry::http_seed); - return r; + return sync_call_ret>(empty, &torrent::web_seeds, web_seed_entry::http_seed); } void torrent_handle::replace_trackers( std::vector const& urls) const { - TORRENT_ASYNC_CALL1(replace_trackers, urls); + async_call(&torrent::replace_trackers, urls); } void torrent_handle::add_tracker(announce_entry const& url) const { - TORRENT_ASYNC_CALL1(add_tracker, url); + async_call(&torrent::add_tracker, url); } void torrent_handle::add_piece(int piece, char const* data, int flags) const { - TORRENT_SYNC_CALL3(add_piece, piece, data, flags); + sync_call(&torrent::add_piece, piece, data, flags); } void torrent_handle::read_piece(int piece) const { - TORRENT_ASYNC_CALL1(read_piece, piece); + async_call(&torrent::read_piece, piece); } bool torrent_handle::have_piece(int piece) const { - TORRENT_SYNC_CALL_RET1(bool, false, have_piece, piece); - return r; + return sync_call_ret(false, &torrent::have_piece, piece); } storage_interface* torrent_handle::get_storage_impl() const { - TORRENT_SYNC_CALL_RET(storage_interface*, 0, get_storage); - return r; + return sync_call_ret(nullptr, &torrent::get_storage); } bool torrent_handle::is_valid() const @@ -639,9 +594,8 @@ namespace libtorrent boost::shared_ptr torrent_handle::torrent_file() const { - TORRENT_SYNC_CALL_RET(boost::shared_ptr - , boost::shared_ptr(), get_torrent_copy); - return r; + return sync_call_ret>( + boost::shared_ptr(), &torrent::get_torrent_copy); } #ifndef TORRENT_NO_DEPRECATE @@ -665,34 +619,33 @@ namespace libtorrent entry torrent_handle::write_resume_data() const { entry ret(entry::dictionary_t); - TORRENT_SYNC_CALL1(write_resume_data, boost::ref(ret)); + auto retr = std::ref(ret); + sync_call(&torrent::write_resume_data, retr); return ret; } std::string torrent_handle::save_path() const { - TORRENT_SYNC_CALL_RET(std::string, "", save_path); - return r; + return sync_call_ret("", &torrent::save_path); } std::string torrent_handle::name() const { - TORRENT_SYNC_CALL_RET(std::string, "", name); - return r; + return sync_call_ret("", &torrent::name); } #endif void torrent_handle::connect_peer(tcp::endpoint const& adr, int source, int flags) const { - TORRENT_ASYNC_CALL3(add_peer, adr, source, flags); + async_call(&torrent::add_peer, adr, source, flags); } #ifndef TORRENT_NO_DEPRECATE void torrent_handle::force_reannounce( boost::posix_time::time_duration duration) const { - TORRENT_ASYNC_CALL2(force_tracker_request, aux::time_now() + async_call(&torrent::force_tracker_request, aux::time_now() + seconds(duration.total_seconds()), -1); } #endif @@ -700,13 +653,13 @@ namespace libtorrent void torrent_handle::force_dht_announce() const { #ifndef TORRENT_DISABLE_DHT - TORRENT_ASYNC_CALL(dht_announce); + async_call(&torrent::dht_announce); #endif } void torrent_handle::force_reannounce(int s, int idx) const { - TORRENT_ASYNC_CALL2(force_tracker_request, aux::time_now() + seconds(s), idx); + async_call(&torrent::force_tracker_request, aux::time_now() + seconds(s), idx); } void torrent_handle::file_status(std::vector& status) const @@ -721,42 +674,45 @@ namespace libtorrent void torrent_handle::scrape_tracker(int idx) const { - TORRENT_ASYNC_CALL2(scrape_tracker, idx, true); + async_call(&torrent::scrape_tracker, idx, true); } void torrent_handle::super_seeding(bool on) const { - TORRENT_ASYNC_CALL1(super_seeding, on); + async_call(&torrent::set_super_seeding, on); } void torrent_handle::get_full_peer_list(std::vector& v) const { - TORRENT_SYNC_CALL1(get_full_peer_list, &v); + auto vp = &v; + sync_call(&torrent::get_full_peer_list, vp); } void torrent_handle::get_peer_info(std::vector& v) const { - TORRENT_SYNC_CALL1(get_peer_info, &v); + auto vp = &v; + sync_call(&torrent::get_peer_info, vp); } void torrent_handle::get_download_queue(std::vector& queue) const { - TORRENT_SYNC_CALL1(get_download_queue, &queue); + auto queuep = &queue; + sync_call(&torrent::get_download_queue, queuep); } void torrent_handle::set_piece_deadline(int index, int deadline, int flags) const { - TORRENT_ASYNC_CALL3(set_piece_deadline, index, deadline, flags); + async_call(&torrent::set_piece_deadline, index, deadline, flags); } void torrent_handle::reset_piece_deadline(int index) const { - TORRENT_ASYNC_CALL1(reset_piece_deadline, index); + async_call(&torrent::reset_piece_deadline, index); } void torrent_handle::clear_piece_deadlines() const { - TORRENT_ASYNC_CALL(clear_time_critical); + async_call(&torrent::clear_time_critical); } boost::shared_ptr torrent_handle::native_handle() const diff --git a/src/web_peer_connection.cpp b/src/web_peer_connection.cpp index 9f41c2520..0d4c7017a 100644 --- a/src/web_peer_connection.cpp +++ b/src/web_peer_connection.cpp @@ -581,7 +581,7 @@ void web_peer_connection::handle_redirect(int bytes_left) if (location.empty()) { // we should not try this server again. - t->remove_web_seed(this, errors::missing_location, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::missing_location, op_bittorrent, 2); m_web = NULL; TORRENT_ASSERT(is_disconnecting()); return; @@ -614,7 +614,7 @@ void web_peer_connection::handle_redirect(int bytes_left) size_t i = location.rfind(path); if (i == std::string::npos) { - t->remove_web_seed(this, errors::invalid_redirection, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::invalid_redirection, op_bittorrent, 2); m_web = NULL; TORRENT_ASSERT(is_disconnecting()); return; @@ -630,7 +630,7 @@ void web_peer_connection::handle_redirect(int bytes_left) peer_log(peer_log_alert::info, "LOCATION", "%s", location.c_str()); #endif t->add_web_seed(location, web_seed_entry::url_seed, m_external_auth, m_extra_headers); - t->remove_web_seed(this, errors::redirecting, op_bittorrent, 2); + t->remove_web_seed_conn(this, errors::redirecting, op_bittorrent, 2); m_web = NULL; TORRENT_ASSERT(is_disconnecting()); return; @@ -763,7 +763,7 @@ void web_peer_connection::on_receive(error_code const& error { received_bytes(0, recv_buffer.left()); // we should not try this server again. - t->remove_web_seed(this, ec, op_bittorrent, 2); + t->remove_web_seed_conn(this, ec, op_bittorrent, 2); m_web = NULL; TORRENT_ASSERT(is_disconnecting()); return;