diff --git a/include/libtorrent/aux_/session_impl.hpp b/include/libtorrent/aux_/session_impl.hpp index 597b6595c..256c0d6a0 100644 --- a/include/libtorrent/aux_/session_impl.hpp +++ b/include/libtorrent/aux_/session_impl.hpp @@ -203,8 +203,8 @@ namespace libtorrent #if TORRENT_USE_INVARIANT_CHECKS friend class libtorrent::invariant_access; #endif - typedef std::set > connection_map; - typedef std::unordered_map > torrent_map; + typedef std::set> connection_map; + typedef std::unordered_map> torrent_map; session_impl(io_service& ios); virtual ~session_impl(); @@ -264,7 +264,7 @@ namespace libtorrent // attempts, because this torrent needs more peers. // this is typically done when a torrent starts out and // need the initial push to connect peers - void prioritize_connections(boost::weak_ptr t) override; + void prioritize_connections(std::weak_ptr t) override; tcp::endpoint get_ipv6_interface() const override; tcp::endpoint get_ipv4_interface() const override; @@ -279,26 +279,26 @@ namespace libtorrent void incoming_connection(boost::shared_ptr const& s); - boost::weak_ptr find_torrent(sha1_hash const& info_hash) const override; + std::weak_ptr find_torrent(sha1_hash const& info_hash) const override; #ifndef TORRENT_NO_DEPRECATE //deprecated in 1.2 - boost::weak_ptr find_torrent(std::string const& uuid) const; + std::weak_ptr find_torrent(std::string const& uuid) const; #endif #ifndef TORRENT_DISABLE_MUTABLE_TORRENTS - std::vector > find_collection( + std::vector> find_collection( std::string const& collection) const override; #endif - boost::weak_ptr find_disconnect_candidate_torrent() const override; + std::weak_ptr find_disconnect_candidate_torrent() const override; int num_torrents() const override { return int(m_torrents.size()); } - void insert_torrent(sha1_hash const& ih, boost::shared_ptr const& t + void insert_torrent(sha1_hash const& ih, std::shared_ptr const& t , std::string uuid) override; #ifndef TORRENT_NO_DEPRECATE //deprecated in 1.2 - void insert_uuid_torrent(std::string uuid, boost::shared_ptr const& t) override + void insert_uuid_torrent(std::string uuid, std::shared_ptr const& t) override { m_uuids.insert(std::make_pair(uuid, t)); } #endif - boost::shared_ptr delay_load_torrent(sha1_hash const& info_hash + std::shared_ptr delay_load_torrent(sha1_hash const& info_hash , peer_connection* pc) override; void set_queue_position(torrent* t, int p) override; @@ -335,7 +335,7 @@ namespace libtorrent // this is called for torrents when they are started // it will prioritize them for announcing to // the DHT, to get the initial peers quickly - void prioritize_dht(boost::weak_ptr t) override; + void prioritize_dht(std::weak_ptr t) override; void get_immutable_callback(sha1_hash target , dht::item const& i); @@ -374,7 +374,7 @@ namespace libtorrent torrent const* find_encrypted_torrent( sha1_hash const& info_hash, sha1_hash const& xor_mask) override; - void add_obfuscated_hash(sha1_hash const& obfuscated, boost::weak_ptr const& t) override; + void add_obfuscated_hash(sha1_hash const& obfuscated, std::weak_ptr const& t) override; #endif void on_port_map_log(char const* msg, int map_transport); @@ -403,7 +403,7 @@ namespace libtorrent void ban_ip(address addr) override; void queue_tracker_request(tracker_request& req - , boost::weak_ptr c) override; + , std::weak_ptr c) override; // ==== peer class operations ==== @@ -432,19 +432,19 @@ namespace libtorrent #ifndef TORRENT_DISABLE_EXTENSIONS void add_extensions_to_torrent( - boost::shared_ptr const& torrent_ptr, void* userdata); + std::shared_ptr const& torrent_ptr, void* userdata); #endif torrent_handle add_torrent(add_torrent_params const&, error_code& ec); // second return value is true if the torrent was added and false if an // existing one was found. - std::pair, bool> + std::pair, bool> add_torrent_impl(add_torrent_params& p, error_code& ec); void async_add_torrent(add_torrent_params* params); void on_async_load_torrent(disk_io_job const* j); void remove_torrent(torrent_handle const& h, int options) override; - void remove_torrent_impl(boost::shared_ptr tptr, int options) override; + void remove_torrent_impl(std::shared_ptr tptr, int options) override; void get_torrent_status(std::vector* ret , std::function const& pred @@ -818,7 +818,7 @@ namespace libtorrent #ifndef TORRENT_NO_DEPRECATE //deprecated in 1.2 - std::map > m_uuids; + std::map> m_uuids; #endif // peer connections are put here when disconnected to avoid @@ -827,7 +827,7 @@ namespace libtorrent // once a peer is disconnected, it's put in this list and // every second their refcount is checked, and if it's 1, // they are deleted (from the network thread) - std::vector > m_undead_peers; + std::vector> m_undead_peers; // keep the io_service alive until we have posted the job // to clear the undead peers @@ -1115,11 +1115,11 @@ namespace libtorrent // in this queue and get announced the next time // the timer fires, instead of the next one in // the round-robin sequence. - std::deque > m_dht_torrents; + std::deque> m_dht_torrents; #endif // torrents prioritized to get connection attempts - std::deque, int> > m_prio_torrents; + std::deque, int>> m_prio_torrents; // this announce timer is used // by Local service discovery diff --git a/include/libtorrent/aux_/session_interface.hpp b/include/libtorrent/aux_/session_interface.hpp index 0a02ba7ec..bf2c51283 100644 --- a/include/libtorrent/aux_/session_interface.hpp +++ b/include/libtorrent/aux_/session_interface.hpp @@ -169,7 +169,7 @@ namespace libtorrent { namespace aux virtual void evict_torrent(torrent* t) = 0; virtual void remove_torrent(torrent_handle const& h, int options = 0) = 0; - virtual void remove_torrent_impl(boost::shared_ptr tptr, int options) = 0; + virtual void remove_torrent_impl(std::shared_ptr tptr, int options) = 0; // port filter virtual port_filter const& get_port_filter() const = 0; @@ -183,15 +183,15 @@ namespace libtorrent { namespace aux virtual void trigger_optimistic_unchoke() = 0; virtual void trigger_unchoke() = 0; - virtual boost::weak_ptr find_torrent(sha1_hash const& info_hash) const = 0; - virtual boost::weak_ptr find_disconnect_candidate_torrent() const = 0; - virtual boost::shared_ptr delay_load_torrent(sha1_hash const& info_hash + virtual std::weak_ptr find_torrent(sha1_hash const& info_hash) const = 0; + virtual std::weak_ptr find_disconnect_candidate_torrent() const = 0; + virtual std::shared_ptr delay_load_torrent(sha1_hash const& info_hash , peer_connection* pc) = 0; - virtual void insert_torrent(sha1_hash const& ih, boost::shared_ptr const& t + virtual void insert_torrent(sha1_hash const& ih, std::shared_ptr const& t , std::string uuid) = 0; #ifndef TORRENT_NO_DEPRECATE //deprecated in 1.2 - virtual void insert_uuid_torrent(std::string uuid, boost::shared_ptr const& t) = 0; + virtual void insert_uuid_torrent(std::string uuid, std::shared_ptr const& t) = 0; #endif virtual void set_queue_position(torrent* t, int p) = 0; virtual int num_torrents() const = 0; @@ -229,7 +229,7 @@ namespace libtorrent { namespace aux , error_code& ec) = 0; #ifndef TORRENT_DISABLE_MUTABLE_TORRENTS - virtual std::vector > find_collection( + virtual std::vector> find_collection( std::string const& collection) const = 0; #endif @@ -241,7 +241,7 @@ namespace libtorrent { namespace aux virtual char const* i2p_session() const = 0; #endif - virtual void prioritize_connections(boost::weak_ptr t) = 0; + virtual void prioritize_connections(std::weak_ptr t) = 0; virtual tcp::endpoint get_ipv4_interface() const = 0; virtual tcp::endpoint get_ipv6_interface() const = 0; @@ -252,7 +252,7 @@ namespace libtorrent { namespace aux virtual session_settings const& settings() const = 0; virtual void queue_tracker_request(tracker_request& req - , boost::weak_ptr c) = 0; + , std::weak_ptr c) = 0; // peer-classes virtual void set_peer_classes(peer_class_set* s, address const& a, int st) = 0; @@ -323,7 +323,7 @@ namespace libtorrent { namespace aux virtual torrent const* find_encrypted_torrent( sha1_hash const& info_hash, sha1_hash const& xor_mask) = 0; virtual void add_obfuscated_hash(sha1_hash const& obfuscated - , boost::weak_ptr const& t) = 0; + , std::weak_ptr const& t) = 0; #endif #ifndef TORRENT_DISABLE_DHT @@ -332,7 +332,7 @@ namespace libtorrent { namespace aux virtual bool has_dht() const = 0; virtual int external_udp_port() const = 0; virtual dht::dht_tracker* dht() = 0; - virtual void prioritize_dht(boost::weak_ptr t) = 0; + virtual void prioritize_dht(std::weak_ptr t) = 0; #endif virtual counters& stats_counters() = 0; diff --git a/include/libtorrent/http_tracker_connection.hpp b/include/libtorrent/http_tracker_connection.hpp index a8dc1bef7..56c6cbf9a 100644 --- a/include/libtorrent/http_tracker_connection.hpp +++ b/include/libtorrent/http_tracker_connection.hpp @@ -70,7 +70,7 @@ namespace libtorrent io_service& ios , tracker_manager& man , tracker_request const& req - , boost::weak_ptr c); + , std::weak_ptr c); void start(); void close(); diff --git a/include/libtorrent/peer_connection.hpp b/include/libtorrent/peer_connection.hpp index e5c418fd0..d47b0a9f7 100644 --- a/include/libtorrent/peer_connection.hpp +++ b/include/libtorrent/peer_connection.hpp @@ -163,7 +163,7 @@ namespace libtorrent buffer_allocator_interface* allocator; disk_interface* disk_thread; io_service* ios; - boost::weak_ptr tor; + std::weak_ptr tor; boost::shared_ptr s; tcp::endpoint endp; torrent_peer* peerinfo; @@ -176,7 +176,7 @@ namespace libtorrent { // if tor is set, this is an outgoing connection peer_connection_hot_members( - boost::weak_ptr t + std::weak_ptr t , aux::session_interface& ses , aux::session_settings const& sett) : m_torrent(t) @@ -207,7 +207,7 @@ namespace libtorrent // the first cache line) and make the constructor // take a raw pointer. torrent objects should always // outlive their peers - boost::weak_ptr m_torrent; + std::weak_ptr m_torrent; public: @@ -451,7 +451,7 @@ namespace libtorrent // may be zero if the connection is an incoming connection // and it hasn't received enough information to determine // which torrent it should be associated with - boost::weak_ptr associated_torrent() const + std::weak_ptr associated_torrent() const { return m_torrent; } stat const& statistics() const { return m_statistics; } @@ -790,7 +790,7 @@ namespace libtorrent void on_disk_read_complete(disk_io_job const* j, peer_request r , time_point issue_time); void on_disk_write_complete(disk_io_job const* j - , peer_request r, boost::shared_ptr t); + , peer_request r, std::shared_ptr t); void on_seed_mode_hashed(disk_io_job const* j); int request_timeout() const; void check_graceful_pause(); diff --git a/include/libtorrent/storage.hpp b/include/libtorrent/storage.hpp index 121d63b43..81b8ea118 100644 --- a/include/libtorrent/storage.hpp +++ b/include/libtorrent/storage.hpp @@ -561,7 +561,7 @@ namespace libtorrent piece_manager( storage_interface* storage_impl - , boost::shared_ptr const& torrent + , std::shared_ptr const& torrent , file_storage* files); ~piece_manager(); @@ -610,7 +610,7 @@ namespace libtorrent // to keep the torrent object alive until // the piece_manager destructs. This is because // the torrent_info object is owned by the torrent. - boost::shared_ptr m_torrent; + std::shared_ptr m_torrent; }; // this identifies a read or write operation so that readwritev() knows diff --git a/include/libtorrent/torrent.hpp b/include/libtorrent/torrent.hpp index 6ddd453d8..d5a00610a 100644 --- a/include/libtorrent/torrent.hpp +++ b/include/libtorrent/torrent.hpp @@ -266,7 +266,7 @@ namespace libtorrent , private torrent_hot_members , public request_callback , public peer_class_set - , public boost::enable_shared_from_this + , public std::enable_shared_from_this , public list_node // used for torrent activity LRU { public: @@ -1125,13 +1125,13 @@ namespace libtorrent void update_tracker_timer(time_point now); - static void on_tracker_announce_disp(boost::weak_ptr p + static void on_tracker_announce_disp(std::weak_ptr p , error_code const& e); void on_tracker_announce(); #ifndef TORRENT_DISABLE_DHT - static void on_dht_announce_response_disp(boost::weak_ptr t + static void on_dht_announce_response_disp(std::weak_ptr t , std::vector const& peers); void on_dht_announce_response(std::vector const& peers); bool should_announce_dht() const; diff --git a/include/libtorrent/torrent_handle.hpp b/include/libtorrent/torrent_handle.hpp index 231a2c7f8..545a41f66 100644 --- a/include/libtorrent/torrent_handle.hpp +++ b/include/libtorrent/torrent_handle.hpp @@ -1285,7 +1285,7 @@ namespace libtorrent // This function is intended only for use by plugins and the alert // dispatch function. This type does not have a stable API and should // be relied on as little as possible. - boost::shared_ptr native_handle() const; + std::shared_ptr native_handle() const; private: @@ -1298,10 +1298,10 @@ namespace libtorrent template Ret sync_call_ret(Ret def, Fun f, Args&&... a) const; - torrent_handle(boost::weak_ptr const& t) + torrent_handle(std::weak_ptr const& t) { if (!t.expired()) m_torrent = t; } - boost::weak_ptr m_torrent; + std::weak_ptr m_torrent; }; diff --git a/include/libtorrent/tracker_manager.hpp b/include/libtorrent/tracker_manager.hpp index eec80827a..f9190946e 100644 --- a/include/libtorrent/tracker_manager.hpp +++ b/include/libtorrent/tracker_manager.hpp @@ -297,12 +297,12 @@ namespace libtorrent tracker_connection(tracker_manager& man , tracker_request const& req , io_service& ios - , boost::weak_ptr r); + , std::weak_ptr r); void update_transaction_id(boost::shared_ptr c , std::uint64_t tid); - boost::shared_ptr requester() const; + std::shared_ptr requester() const; virtual ~tracker_connection() {} tracker_request const& tracker_req() const { return m_req; } @@ -330,7 +330,7 @@ namespace libtorrent void fail_impl(error_code const& ec, int code = -1, std::string msg = std::string() , int interval = 0, int min_interval = 0); - boost::weak_ptr m_requester; + std::weak_ptr m_requester; tracker_manager& m_man; }; @@ -362,8 +362,8 @@ namespace libtorrent void queue_request( io_service& ios , tracker_request r - , boost::weak_ptr c - = boost::weak_ptr()); + , std::weak_ptr c + = std::weak_ptr()); void abort_all_requests(bool all = false); void remove_request(tracker_connection const*); diff --git a/include/libtorrent/udp_tracker_connection.hpp b/include/libtorrent/udp_tracker_connection.hpp index a22a13841..58fe0702e 100644 --- a/include/libtorrent/udp_tracker_connection.hpp +++ b/include/libtorrent/udp_tracker_connection.hpp @@ -63,7 +63,7 @@ namespace libtorrent io_service& ios , tracker_manager& man , tracker_request const& req - , boost::weak_ptr c); + , std::weak_ptr c); void start(); void close(); diff --git a/src/alert.cpp b/src/alert.cpp index ff65777ce..f33cc99e7 100644 --- a/src/alert.cpp +++ b/src/alert.cpp @@ -60,7 +60,7 @@ namespace libtorrent { : handle(h) , m_alloc(alloc) { - boost::shared_ptr t = h.native_handle(); + std::shared_ptr t = h.native_handle(); if (t) { std::string name_str = t->name(); diff --git a/src/bt_peer_connection.cpp b/src/bt_peer_connection.cpp index 85ebee397..cceb8854a 100644 --- a/src/bt_peer_connection.cpp +++ b/src/bt_peer_connection.cpp @@ -210,7 +210,7 @@ namespace libtorrent { if (is_disconnecting()) return; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); if (t->graceful_pause()) @@ -324,7 +324,7 @@ namespace libtorrent if (m_sent_bitfield) return; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); write_bitfield(); TORRENT_ASSERT(m_sent_bitfield); @@ -437,7 +437,7 @@ namespace libtorrent TORRENT_ASSERT(m_sent_handshake); TORRENT_ASSERT(m_sent_bitfield); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->valid_metadata()); @@ -551,7 +551,7 @@ namespace libtorrent TORRENT_ASSERT(is_outgoing()); TORRENT_ASSERT(!m_sent_handshake); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); hasher h; @@ -758,7 +758,7 @@ namespace libtorrent TORRENT_ASSERT(!m_sent_handshake); m_sent_handshake = true; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); // add handshake to the send buffer @@ -843,7 +843,7 @@ namespace libtorrent boost::optional bt_peer_connection::downloading_piece_progress() const { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); span recv_buffer = m_recv_buffer.get(); @@ -916,7 +916,7 @@ namespace libtorrent // assume that the choke message implies that all // of our requests are rejected. Go through them and // pretend that we received reject request messages - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); while (!download_queue().empty()) { @@ -1044,7 +1044,7 @@ namespace libtorrent TORRENT_ASSERT(received >= 0); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); received_bytes(0, received); @@ -1109,7 +1109,7 @@ namespace libtorrent span recv_buffer = m_recv_buffer.get(); int recv_pos = m_recv_buffer.pos(); // recv_buffer.end - recv_buffer.begin; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); bool const merkle = static_cast(recv_buffer.front()) == 250; if (merkle) @@ -1483,7 +1483,7 @@ namespace libtorrent return; // unknown address type } - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); if (!t) return; switch (msg_type) @@ -1747,7 +1747,7 @@ namespace libtorrent { if (!m_recv_buffer.packet_finished()) return; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); span recv_buffer = m_recv_buffer.get(); @@ -1955,7 +1955,7 @@ namespace libtorrent { INVARIANT_CHECK; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); if (m_upload_only_id == 0) return; if (t->share_mode()) return; @@ -1987,7 +1987,7 @@ namespace libtorrent { INVARIANT_CHECK; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); if (m_share_mode_id == 0) return; char msg[7] = {0, 0, 0, 3, msg_extended}; @@ -2064,7 +2064,7 @@ namespace libtorrent // know whether to send a have-all or have-none? TORRENT_ASSERT(m_state >= state_t::read_peer_id); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(m_sent_handshake); TORRENT_ASSERT(t->valid_metadata()); @@ -2201,7 +2201,7 @@ namespace libtorrent #endif handshake["yourip"] = remote_address; handshake["reqq"] = m_settings.get_int(settings_pack::max_allowed_in_request_queue); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); m["upload_only"] = upload_only_msg; @@ -2409,7 +2409,7 @@ namespace libtorrent TORRENT_ASSERT(m_sent_handshake); TORRENT_ASSERT(m_sent_bitfield); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); bool merkle = t->torrent_file().is_merkle_torrent() && r.start == 0; @@ -2553,7 +2553,7 @@ namespace libtorrent void bt_peer_connection::on_receive_impl(std::size_t bytes_transferred) { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); span recv_buffer = m_recv_buffer.get(); @@ -3561,7 +3561,7 @@ namespace libtorrent if (amount_payload > 0) { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); if (t) t->update_last_upload(); } @@ -3570,7 +3570,7 @@ namespace libtorrent #if TORRENT_USE_INVARIANT_CHECKS void bt_peer_connection::check_invariant() const { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) TORRENT_ASSERT( (bool(m_state != state_t::read_pe_dhkey) || m_dh_key_exchange.get()) diff --git a/src/choker.cpp b/src/choker.cpp index dc37ced18..b534e423e 100644 --- a/src/choker.cpp +++ b/src/choker.cpp @@ -50,9 +50,9 @@ namespace libtorrent { // if one peer belongs to a higher priority torrent than the other one // that one should be unchoked. - boost::shared_ptr t1 = lhs->associated_torrent().lock(); + std::shared_ptr t1 = lhs->associated_torrent().lock(); TORRENT_ASSERT(t1); - boost::shared_ptr t2 = rhs->associated_torrent().lock(); + std::shared_ptr t2 = rhs->associated_torrent().lock(); TORRENT_ASSERT(t2); int prio1 = lhs->get_priority(peer_connection::upload_channel); @@ -113,9 +113,9 @@ namespace libtorrent { // if one peer belongs to a higher priority torrent than the other one // that one should be unchoked. - boost::shared_ptr t1 = lhs->associated_torrent().lock(); + std::shared_ptr t1 = lhs->associated_torrent().lock(); TORRENT_ASSERT(t1); - boost::shared_ptr t2 = rhs->associated_torrent().lock(); + std::shared_ptr t2 = rhs->associated_torrent().lock(); TORRENT_ASSERT(t2); int prio1 = lhs->get_priority(peer_connection::upload_channel); @@ -155,9 +155,9 @@ namespace libtorrent { // if one peer belongs to a higher priority torrent than the other one // that one should be unchoked. - boost::shared_ptr t1 = lhs->associated_torrent().lock(); + std::shared_ptr t1 = lhs->associated_torrent().lock(); TORRENT_ASSERT(t1); - boost::shared_ptr t2 = rhs->associated_torrent().lock(); + std::shared_ptr t2 = rhs->associated_torrent().lock(); TORRENT_ASSERT(t2); int prio1 = lhs->get_priority(peer_connection::upload_channel); diff --git a/src/create_torrent.cpp b/src/create_torrent.cpp index 19d66b01f..8f50d1a57 100644 --- a/src/create_torrent.cpp +++ b/src/create_torrent.cpp @@ -268,7 +268,7 @@ namespace libtorrent } // dummy torrent object pointer - boost::shared_ptr dummy; + std::shared_ptr dummy; counters cnt; disk_io_thread disk_thread(ios, cnt, nullptr); disk_thread.set_num_threads(1); diff --git a/src/http_seed_connection.cpp b/src/http_seed_connection.cpp index 78bc31ed5..881d92dc0 100644 --- a/src/http_seed_connection.cpp +++ b/src/http_seed_connection.cpp @@ -57,7 +57,7 @@ namespace libtorrent if (!m_settings.get_bool(settings_pack::report_web_seed_downloads)) ignore_stats(true); - shared_ptr tor = pack.tor.lock(); + std::shared_ptr tor = pack.tor.lock(); TORRENT_ASSERT(tor); int blocks_per_piece = tor->torrent_file().piece_length() / tor->block_size(); @@ -85,7 +85,7 @@ namespace libtorrent m_web->endpoints.erase(m_web->endpoints.begin()); } - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); peer_connection::disconnect(ec, op, error); if (t) t->disconnect_web_seed(this); } @@ -96,7 +96,7 @@ namespace libtorrent if (m_requests.empty()) return boost::optional(); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); piece_block_progress ret; @@ -132,7 +132,7 @@ namespace libtorrent { INVARIANT_CHECK; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->valid_metadata()); @@ -210,7 +210,7 @@ namespace libtorrent return; } - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); for (;;) diff --git a/src/http_tracker_connection.cpp b/src/http_tracker_connection.cpp index 049d9c03c..f2635d4a5 100644 --- a/src/http_tracker_connection.cpp +++ b/src/http_tracker_connection.cpp @@ -65,7 +65,7 @@ namespace libtorrent io_service& ios , tracker_manager& man , tracker_request const& req - , boost::weak_ptr c) + , std::weak_ptr c) : tracker_connection(man, req, ios, c) , m_man(man) #if TORRENT_USE_I2P @@ -239,7 +239,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) { cb->debug_log("==> TRACKER_REQUEST [ url: %s ]", url.c_str()); @@ -275,7 +275,7 @@ namespace libtorrent } #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) { cb->debug_log("*** TRACKER_FILTER"); @@ -290,7 +290,7 @@ namespace libtorrent error_code ec; tcp::endpoint ep = c.socket().remote_endpoint(ec); m_tracker_ip = ep.address(); - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); } void http_tracker_connection::on_response(error_code const& ec @@ -329,7 +329,7 @@ namespace libtorrent // handle tracker response error_code ecode; - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (!cb) { close(); diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp index aa5f0de73..f4134dd91 100644 --- a/src/peer_connection.cpp +++ b/src/peer_connection.cpp @@ -104,7 +104,7 @@ namespace libtorrent #if TORRENT_USE_ASSERTS bool peer_connection::is_single_thread() const { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return true; return t->is_single_thread(); } @@ -149,7 +149,7 @@ namespace libtorrent else if (m_connecting) m_counters.inc_stats_counter(counters::num_peers_half_open); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); // if t is nullptr, we better not be connecting, since // we can't decrement the connecting counter TORRENT_ASSERT(t || !m_connecting); @@ -221,7 +221,7 @@ namespace libtorrent if (prio < class_prio) prio = class_prio; } - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); if (t) { @@ -245,7 +245,7 @@ namespace libtorrent { TORRENT_ASSERT(is_single_thread()); TORRENT_ASSERT(m_peer_info == nullptr || m_peer_info->connection == this); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!m_outgoing) { @@ -386,7 +386,7 @@ namespace libtorrent TORRENT_ASSERT(m_need_interest_update); m_need_interest_update = false; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; // if m_have_piece is 0, it means the connections @@ -460,7 +460,7 @@ namespace libtorrent va_start(v, fmt); torrent_handle h; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (t) h = t->get_handle(); m_ses.alerts().emplace_alert( @@ -484,7 +484,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (t->super_seeding()) @@ -589,7 +589,7 @@ namespace libtorrent void peer_connection::on_metadata_impl() { TORRENT_ASSERT(is_single_thread()); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); m_have_piece.resize(t->torrent_file().num_pieces(), m_have_all); m_num_pieces = m_have_piece.count(); @@ -623,7 +623,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->valid_metadata()); TORRENT_ASSERT(t->ready_for_connections()); @@ -730,7 +730,7 @@ namespace libtorrent m_counters.inc_stats_counter(counters::num_peers_down_requests, -1); // defensive - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); // if t is nullptr, we better not be connecting, since // we can't decrement the connecting counter TORRENT_ASSERT(t || !m_connecting); @@ -768,7 +768,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); int ret = m_picker_options; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (!t) return 0; @@ -863,7 +863,7 @@ namespace libtorrent if (disconnect_if_redundant()) return; #if TORRENT_USE_ASSERTS - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #endif } @@ -892,7 +892,7 @@ namespace libtorrent #endif write_have(index); #if TORRENT_USE_ASSERTS - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #endif } @@ -900,7 +900,7 @@ namespace libtorrent bool peer_connection::has_piece(int i) const { TORRENT_ASSERT(is_single_thread()); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->valid_metadata()); TORRENT_ASSERT(i >= 0); @@ -929,7 +929,7 @@ namespace libtorrent time_duration peer_connection::download_queue_time(int extra_bytes) const { TORRENT_ASSERT(is_single_thread()); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); int rate = 0; @@ -981,7 +981,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); m_statistics.received_bytes(bytes_payload, bytes_protocol); if (m_ignore_stats) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; t->received_bytes(bytes_payload, bytes_protocol); } @@ -1000,7 +1000,7 @@ namespace libtorrent } #endif if (m_ignore_stats) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; t->sent_bytes(bytes_payload, bytes_protocol); } @@ -1010,7 +1010,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); m_statistics.trancieve_ip_packet(bytes, ipv6); if (m_ignore_stats) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; t->trancieve_ip_packet(bytes, ipv6); } @@ -1020,7 +1020,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); m_statistics.sent_syn(ipv6); if (m_ignore_stats) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; t->sent_syn(ipv6); } @@ -1030,7 +1030,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); m_statistics.received_synack(ipv6); if (m_ignore_stats) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; t->received_synack(ipv6); } @@ -1086,7 +1086,7 @@ namespace libtorrent bool peer_connection::verify_piece(const peer_request& p) const { TORRENT_ASSERT(is_single_thread()); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->valid_metadata()); @@ -1111,8 +1111,8 @@ namespace libtorrent TORRENT_ASSERT(!m_disconnecting); TORRENT_ASSERT(m_torrent.expired()); - boost::weak_ptr wpt = m_ses.find_torrent(ih); - boost::shared_ptr t = wpt.lock(); + std::weak_ptr wpt = m_ses.find_torrent(ih); + std::shared_ptr t = wpt.lock(); if (t && t->is_aborted()) { @@ -1208,8 +1208,8 @@ namespace libtorrent { // find a peer in some torrent (presumably the one with most peers) // and disconnect the lowest ranking peer - boost::weak_ptr torr = m_ses.find_disconnect_candidate_torrent(); - boost::shared_ptr other_t = torr.lock(); + std::weak_ptr torr = m_ses.find_disconnect_candidate_torrent(); + std::shared_ptr other_t = torr.lock(); if (other_t) { @@ -1313,7 +1313,7 @@ namespace libtorrent void peer_connection::clear_request_queue() { TORRENT_ASSERT(is_single_thread()); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (!t->has_picker()) { @@ -1357,7 +1357,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_LOGGING @@ -1455,7 +1455,7 @@ namespace libtorrent peer_log(peer_log_alert::incoming_message, "SUGGEST_PIECE" , "piece: %d", index); #endif - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return; #ifndef TORRENT_DISABLE_EXTENSIONS @@ -1516,7 +1516,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_LOGGING @@ -1559,7 +1559,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS @@ -1630,7 +1630,7 @@ namespace libtorrent // if the peer is choked and we have upload slots left, // then unchoke it. - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); t->unchoke_peer(*this); @@ -1672,7 +1672,7 @@ namespace libtorrent m_peer_interested = false; if (is_disconnecting()) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); choke_this_peer(); @@ -1688,7 +1688,7 @@ namespace libtorrent return; } - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (m_peer_info && m_peer_info->optimistically_unchoked) @@ -1710,7 +1710,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS @@ -1883,7 +1883,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS @@ -1941,7 +1941,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS @@ -2069,7 +2069,7 @@ namespace libtorrent TORRENT_ASSERT(m_in_constructor == false); if (!m_settings.get_bool(settings_pack::close_redundant_connections)) return false; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t) return false; // if we don't have the metadata yet, don't disconnect @@ -2130,7 +2130,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); m_counters.inc_stats_counter(counters::piece_requests); @@ -2399,7 +2399,7 @@ namespace libtorrent TORRENT_ASSERT(m_outstanding_bytes >= bytes); m_outstanding_bytes -= bytes; if (m_outstanding_bytes < 0) m_outstanding_bytes = 0; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); #if TORRENT_USE_ASSERTS TORRENT_ASSERT(m_received_in_piece + bytes <= t->block_size()); m_received_in_piece += bytes; @@ -2425,7 +2425,7 @@ namespace libtorrent TORRENT_ASSERT(recv_pos >= 9); #endif - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); if (!verify_piece(r)) @@ -2491,7 +2491,7 @@ namespace libtorrent #if TORRENT_USE_INVARIANT_CHECKS struct check_postcondition { - explicit check_postcondition(boost::shared_ptr const& t_ + explicit check_postcondition(std::shared_ptr const& t_ , bool init_check = true): t(t_) { if (init_check) check(); } ~check_postcondition() { check(); } @@ -2514,7 +2514,7 @@ namespace libtorrent } } - shared_ptr t; + std::shared_ptr t; }; #endif @@ -2561,7 +2561,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); // we're not receiving any block right now @@ -2881,7 +2881,7 @@ namespace libtorrent // should update them when it enters graceful pause). When a peer enters // graceful pause mode, it should cancel all outstanding requests and // clear its request queue. - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t || !t->graceful_pause()) return; if (m_outstanding_bytes > 0) return; @@ -2893,7 +2893,7 @@ namespace libtorrent } void peer_connection::on_disk_write_complete(disk_io_job const* j - , peer_request p, boost::shared_ptr t) + , peer_request p, std::shared_ptr t) { TORRENT_ASSERT(is_single_thread()); torrent_ref_holder h(t.get(), "async_write"); @@ -3072,7 +3072,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); // we cannot disconnect in a constructor, and @@ -3161,7 +3161,7 @@ namespace libtorrent peer_log(peer_log_alert::incoming_message, "HAVE_NONE"); #endif - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS @@ -3206,7 +3206,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_LOGGING @@ -3274,7 +3274,7 @@ namespace libtorrent std::vector const& peer_connection::allowed_fast() { TORRENT_ASSERT(is_single_thread()); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); // TODO: sort the allowed fast set in priority order @@ -3289,7 +3289,7 @@ namespace libtorrent > m_desired_queue_size * 2) return false; if (on_parole()) return false; if (m_disconnecting) return false; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (t->upload_mode()) return false; @@ -3306,7 +3306,7 @@ namespace libtorrent , m_request_queue.end(), has_block(block)); if (rit == m_request_queue.end()) return false; #if TORRENT_USE_ASSERTS - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->has_picker()); TORRENT_ASSERT(t->picker().is_requested(block)); @@ -3325,7 +3325,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(!m_disconnecting); @@ -3435,7 +3435,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); // this peer might be disconnecting if (!t) return; @@ -3491,7 +3491,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); // this peer might be disconnecting if (!t) return; @@ -3621,7 +3621,7 @@ namespace libtorrent INVARIANT_CHECK; if (!m_choked) return false; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t->ready_for_connections()) return false; if (m_settings.get_int(settings_pack::suggest_mode) @@ -3651,7 +3651,7 @@ namespace libtorrent { TORRENT_ASSERT(is_single_thread()); if (m_interesting) return; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t->ready_for_connections()) return; m_interesting = true; m_counters.inc_stats_counter(counters::num_peers_down_interested); @@ -3675,7 +3675,7 @@ namespace libtorrent return; } - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t->ready_for_connections()) return; m_interesting = false; m_slow_start = false; @@ -3695,7 +3695,7 @@ namespace libtorrent void peer_connection::send_piece_suggestions(int const num) { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); int const new_suggestions = t->get_suggest_pieces(m_suggest_pieces @@ -3729,7 +3729,7 @@ namespace libtorrent // we cannot suggest a piece we don't have! #if TORRENT_USE_ASSERTS { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->has_piece_passed(piece)); TORRENT_ASSERT(piece >= 0 && piece < t->torrent_file().num_pieces()); @@ -3744,7 +3744,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (m_disconnecting) return; @@ -3911,7 +3911,7 @@ namespace libtorrent m_counters.inc_stats_counter(counters::connect_timeouts); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(!m_connecting || t); if (m_connecting) { @@ -4126,7 +4126,7 @@ namespace libtorrent m_channel_state[download_channel] &= ~peer_info::bw_disk; } - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (m_connecting) { m_counters.inc_stats_counter(counters::num_peers_half_open, -1); @@ -4244,7 +4244,7 @@ namespace libtorrent if (num_classes() == 0) return true; if (m_ses.ignore_unchoke_slots_set(*this)) return true; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (t && m_ses.ignore_unchoke_slots_set(*t)) return true; return false; } @@ -4429,7 +4429,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "SUPER_SEEDING", "ending"); #endif - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); assert(t); // this will either send a full bitfield or @@ -4502,7 +4502,7 @@ namespace libtorrent // the minimum number of requests is 2 and the maximum is 48 // the block size doesn't have to be 16. So we first query the // torrent for it - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); int const block_size = t->block_size(); TORRENT_ASSERT(block_size > 0); @@ -4536,7 +4536,7 @@ namespace libtorrent // in case the peer got disconnected INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); int warning = 0; // drain the IP overhead from the bandwidth limiters @@ -4838,7 +4838,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t); if (!m_snubbed) @@ -4938,7 +4938,7 @@ namespace libtorrent #endif bool sent_a_piece = false; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t || t->is_aborted() || m_requests.empty()) return; // only add new piece-chunks if the send buffer is small enough @@ -5078,7 +5078,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); torrent_ref_holder h(t.get(), "async_seed_hash"); if (t) t->dec_refcount("async_seed_hash"); @@ -5149,7 +5149,7 @@ namespace libtorrent m_reading_bytes -= r.length; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); torrent_ref_holder h(t.get(), "async_read"); if (t) t->dec_refcount("async_read"); @@ -5267,7 +5267,7 @@ namespace libtorrent int peer_connection::wanted_transfer(int channel) { TORRENT_ASSERT(is_single_thread()); - shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); const int tick_interval = (std::max)(1, m_settings.get_int(settings_pack::tick_interval)); @@ -5295,7 +5295,7 @@ namespace libtorrent // we can only have one outstanding bandwidth request at a time if (m_channel_state[channel] & peer_info::bw_limit) return 0; - shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); bytes = (std::max)(wanted_transfer(channel), bytes); @@ -5423,7 +5423,7 @@ namespace libtorrent && !m_requests.empty() && m_reading_bytes > m_settings.get_int(settings_pack::send_buffer_watermark) - 0x4000) { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); // we're stalled on the disk. We want to write and we can write // but our send buffer is empty, waiting to be refilled from the disk @@ -5849,7 +5849,7 @@ namespace libtorrent if (is_seed()) { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (t) t->seen_complete(); } @@ -5876,7 +5876,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); bool bw_limit = m_quota[download_channel] > 0; @@ -5907,7 +5907,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (t) t->debug_log("END connect [%p]", static_cast(this)); m_connect_time = completed; } @@ -5922,7 +5922,7 @@ namespace libtorrent // if t is nullptr, we better not be connecting, since // we can't decrement the connecting counter - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT(t || !m_connecting); if (m_connecting) { @@ -6177,7 +6177,7 @@ namespace libtorrent } } - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); #if TORRENT_USE_INVARIANT_CHECKS \ && !defined TORRENT_NO_EXPENSIVE_INVARIANT_CHECK @@ -6448,7 +6448,7 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); // if m_num_pieces == 0, we probably don't have the // metadata yet. - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); return m_num_pieces == int(m_have_piece.size()) && m_num_pieces > 0 && t && t->valid_metadata(); } @@ -6470,7 +6470,7 @@ namespace libtorrent if (m_upload_only || is_seed()) return; m_upload_only = u; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); t->set_seed(m_peer_info, u); disconnect_if_redundant(); } diff --git a/src/peer_connection_handle.cpp b/src/peer_connection_handle.cpp index 578f575bb..26fbae8a6 100644 --- a/src/peer_connection_handle.cpp +++ b/src/peer_connection_handle.cpp @@ -140,7 +140,7 @@ torrent_handle peer_connection_handle::associated_torrent() const { boost::shared_ptr pc = native_handle(); if (!pc) return torrent_handle(); - boost::shared_ptr t = pc->associated_torrent().lock(); + std::shared_ptr t = pc->associated_torrent().lock(); if (!t) return torrent_handle(); return t->get_handle(); } diff --git a/src/session_handle.cpp b/src/session_handle.cpp index 511ef7cca..5b4c884b6 100644 --- a/src/session_handle.cpp +++ b/src/session_handle.cpp @@ -419,7 +419,7 @@ namespace libtorrent , torrent_handle h, int flags) const { piece_manager* st = nullptr; - boost::shared_ptr t = h.m_torrent.lock(); + std::shared_ptr t = h.m_torrent.lock(); if (t) { if (t->has_storage()) diff --git a/src/session_impl.cpp b/src/session_impl.cpp index 0f7998bed..2f95a686e 100644 --- a/src/session_impl.cpp +++ b/src/session_impl.cpp @@ -281,7 +281,7 @@ namespace aux { return SSL_TLSEXT_ERR_ALERT_FATAL; // see if there is a torrent with this info-hash - boost::shared_ptr t = ses->find_torrent(info_hash).lock(); + std::shared_ptr t = ses->find_torrent(info_hash).lock(); // if there isn't, fail if (!t) return SSL_TLSEXT_ERR_ALERT_FATAL; @@ -1059,7 +1059,7 @@ namespace aux { } void session_impl::queue_tracker_request(tracker_request& req - , boost::weak_ptr c) + , std::weak_ptr c) { req.listen_port = listen_port(); if (m_key) req.key = m_key; @@ -2764,7 +2764,7 @@ namespace aux { pack.allocator = this; pack.disk_thread = &m_disk_thread; pack.ios = &m_io_service; - pack.tor = boost::weak_ptr(); + pack.tor = std::weak_ptr(); pack.s = s; pack.endp = endp; pack.peerinfo = nullptr; @@ -3314,7 +3314,7 @@ namespace aux { for (torrent_map::iterator i = m_torrents.begin() , end(m_torrents.end()); i != end; ++i) { - boost::shared_ptr t = i->second; + std::shared_ptr t = i->second; // ths disconnect logic is disabled for torrents with // too low connection limit @@ -3371,7 +3371,7 @@ namespace aux { m_stats_counters.inc_stats_counter(counters::socket_send_size3 + index); } - void session_impl::prioritize_connections(boost::weak_ptr t) + void session_impl::prioritize_connections(std::weak_ptr t) { m_prio_torrents.push_back(std::make_pair(t, 10)); } @@ -3391,7 +3391,7 @@ namespace aux { return m_dht.get() != nullptr; } - void session_impl::prioritize_dht(boost::weak_ptr t) + void session_impl::prioritize_dht(std::weak_ptr t) { TORRENT_ASSERT(!m_abort); if (m_abort) return; @@ -3399,7 +3399,7 @@ namespace aux { TORRENT_ASSERT(m_dht); m_dht_torrents.push_back(t); #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr tor = t.lock(); + std::shared_ptr tor = t.lock(); if (tor) session_log("prioritizing DHT announce: \"%s\"", tor->name().c_str()); #endif @@ -3466,7 +3466,7 @@ namespace aux { if (!m_dht_torrents.empty()) { - boost::shared_ptr t; + std::shared_ptr t; do { t = m_dht_torrents.front().lock(); @@ -3843,7 +3843,7 @@ namespace aux { else { TORRENT_ASSERT(p->is_choked()); - boost::shared_ptr t = p->associated_torrent().lock(); + std::shared_ptr t = p->associated_torrent().lock(); bool ret = t->unchoke_peer(*p, true); TORRENT_ASSERT(ret); if (ret) @@ -3864,7 +3864,7 @@ namespace aux { { TORRENT_ASSERT(pi->optimistically_unchoked); peer_connection* p = static_cast(pi->connection); - boost::shared_ptr t = p->associated_torrent().lock(); + std::shared_ptr t = p->associated_torrent().lock(); pi->optimistically_unchoked = false; m_stats_counters.inc_stats_counter(counters::num_peers_up_unchoked_optimistic, -1); t->choke_peer(*p); @@ -4184,7 +4184,7 @@ namespace aux { m_delayed_uncorks.clear(); } - boost::shared_ptr session_impl::delay_load_torrent(sha1_hash const& info_hash + std::shared_ptr session_impl::delay_load_torrent(sha1_hash const& info_hash , peer_connection* pc) { #ifndef TORRENT_DISABLE_EXTENSIONS @@ -4203,12 +4203,12 @@ namespace aux { TORRENT_UNUSED(pc); TORRENT_UNUSED(info_hash); #endif - return boost::shared_ptr(); + return std::shared_ptr(); } // the return value from this function is valid only as long as the // session is locked! - boost::weak_ptr session_impl::find_torrent(sha1_hash const& info_hash) const + std::weak_ptr session_impl::find_torrent(sha1_hash const& info_hash) const { TORRENT_ASSERT(is_single_thread()); @@ -4222,10 +4222,10 @@ namespace aux { } #endif if (i != m_torrents.end()) return i->second; - return boost::weak_ptr(); + return std::weak_ptr(); } - void session_impl::insert_torrent(sha1_hash const& ih, boost::shared_ptr const& t + void session_impl::insert_torrent(sha1_hash const& ih, std::shared_ptr const& t , std::string uuid) { m_torrents.insert(std::make_pair(ih, t)); @@ -4333,26 +4333,26 @@ namespace aux { #ifndef TORRENT_NO_DEPRECATE //deprecated in 1.2 - boost::weak_ptr session_impl::find_torrent(std::string const& uuid) const + std::weak_ptr session_impl::find_torrent(std::string const& uuid) const { TORRENT_ASSERT(is_single_thread()); - std::map >::const_iterator i + std::map >::const_iterator i = m_uuids.find(uuid); if (i != m_uuids.end()) return i->second; - return boost::weak_ptr(); + return std::weak_ptr(); } #endif #ifndef TORRENT_DISABLE_MUTABLE_TORRENTS - std::vector > session_impl::find_collection( + std::vector > session_impl::find_collection( std::string const& collection) const { - std::vector > ret; + std::vector > ret; for (session_impl::torrent_map::const_iterator i = m_torrents.begin() , end(m_torrents.end()); i != end; ++i) { - boost::shared_ptr t = i->second; + std::shared_ptr t = i->second; if (!t) continue; std::vector const& c = t->torrent_file().collections(); if (std::count(c.begin(), c.end(), collection) == 0) continue; @@ -4383,13 +4383,13 @@ namespace aux { } // anonymous namespace - boost::weak_ptr session_impl::find_disconnect_candidate_torrent() const + std::weak_ptr session_impl::find_disconnect_candidate_torrent() const { aux::session_impl::torrent_map::const_iterator i = std::min_element(m_torrents.begin(), m_torrents.end() , &compare_disconnect_torrent); TORRENT_ASSERT(i != m_torrents.end()); - if (i == m_torrents.end()) return boost::shared_ptr(); + if (i == m_torrents.end()) return std::shared_ptr(); return i->second; } @@ -4436,7 +4436,7 @@ namespace aux { for (std::vector::iterator i = ret->begin(), end(ret->end()); i != end; ++i) { - boost::shared_ptr t = i->handle.m_torrent.lock(); + std::shared_ptr t = i->handle.m_torrent.lock(); if (!t) continue; t->status(&*i, flags); } @@ -4582,7 +4582,7 @@ namespace aux { #ifndef TORRENT_DISABLE_EXTENSIONS void session_impl::add_extensions_to_torrent( - boost::shared_ptr const& torrent_ptr, void* userdata) + std::shared_ptr const& torrent_ptr, void* userdata) { for (auto& e : m_ses_extensions[plugins_all_idx]) { @@ -4598,7 +4598,7 @@ namespace aux { { // params is updated by add_torrent_impl() add_torrent_params params = p; - boost::shared_ptr torrent_ptr; + std::shared_ptr torrent_ptr; bool added; boost::tie(torrent_ptr, added) = add_torrent_impl(params, ec); @@ -4718,14 +4718,14 @@ namespace aux { return handle; } - std::pair, bool> + std::pair, bool> session_impl::add_torrent_impl( add_torrent_params& params , error_code& ec) { TORRENT_ASSERT(!params.save_path.empty()); - using ptr_t = boost::shared_ptr; + using ptr_t = std::shared_ptr; if (string_begins_no_case("magnet:", params.url.c_str())) { @@ -4798,7 +4798,7 @@ namespace aux { } // is the torrent already active? - boost::shared_ptr torrent_ptr = find_torrent(params.info_hash).lock(); + std::shared_ptr torrent_ptr = find_torrent(params.info_hash).lock(); #ifndef TORRENT_NO_DEPRECATE //deprecated in 1.2 if (!torrent_ptr && !params.uuid.empty()) torrent_ptr = find_torrent(params.uuid).lock(); @@ -4833,7 +4833,7 @@ namespace aux { int queue_pos = ++m_max_queue_pos; - torrent_ptr = boost::make_shared(std::ref(*this) + torrent_ptr = std::make_shared(std::ref(*this) , 16 * 1024, queue_pos, m_paused , boost::cref(params), boost::cref(params.info_hash)); @@ -4946,7 +4946,7 @@ namespace aux { { INVARIANT_CHECK; - boost::shared_ptr tptr = h.m_torrent.lock(); + std::shared_ptr tptr = h.m_torrent.lock(); if (!tptr) return; m_alerts.emplace_alert(tptr->get_handle() @@ -4958,7 +4958,7 @@ namespace aux { tptr->set_queue_position(-1); } - void session_impl::remove_torrent_impl(boost::shared_ptr tptr + void session_impl::remove_torrent_impl(std::shared_ptr tptr , int options) { #ifndef TORRENT_NO_DEPRECATE @@ -4966,7 +4966,7 @@ namespace aux { // remove from uuid list if (!tptr->uuid().empty()) { - std::map >::iterator j + std::map >::iterator j = m_uuids.find(tptr->uuid()); if (j != m_uuids.end()) m_uuids.erase(j); } @@ -5276,7 +5276,7 @@ namespace aux { INVARIANT_CHECK; - boost::shared_ptr t = find_torrent(ih).lock(); + std::shared_ptr t = find_torrent(ih).lock(); if (!t) return; // don't add peers from lsd to private torrents if (t->torrent_file().priv() || (t->torrent_file().is_i2p() @@ -5523,23 +5523,21 @@ namespace aux { m_dht_storage = m_dht_storage_constructor(m_dht_settings); m_dht = std::make_shared( static_cast(this) - , std::ref(m_io_service) + , m_io_service , std::bind(&session_impl::send_udp_packet, this, false, _1, _2, _3, _4) - , std::cref(m_dht_settings) - , std::ref(m_stats_counters) + , m_dht_settings + , m_stats_counters , *m_dht_storage , startup_state); - for (std::vector::iterator i = m_dht_router_nodes.begin() - , end(m_dht_router_nodes.end()); i != end; ++i) + for (auto const& n : m_dht_router_nodes) { - m_dht->add_router_node(*i); + m_dht->add_router_node(n); } - for (std::vector::iterator i = m_dht_nodes.begin() - , end(m_dht_nodes.end()); i != end; ++i) + for (auto const& n : m_dht_nodes) { - m_dht->add_node(*i); + m_dht->add_node(n); } m_dht_nodes.clear(); @@ -5775,7 +5773,7 @@ namespace aux { #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) void session_impl::add_obfuscated_hash(sha1_hash const& obfuscated - , boost::weak_ptr const& t) + , std::weak_ptr const& t) { m_obfuscated_torrents.insert(std::make_pair(obfuscated, t.lock())); } @@ -6726,7 +6724,7 @@ namespace aux { for (torrent_map::const_iterator i = m_torrents.begin() , end(m_torrents.end()); i != end; ++i) { - boost::shared_ptr t = i->second; + std::shared_ptr t = i->second; if (t->want_peers_download()) ++num_active_downloading; if (t->want_peers_finished()) ++num_active_finished; TORRENT_ASSERT(!(t->want_peers_download() && t->want_peers_finished())); @@ -6769,7 +6767,7 @@ namespace aux { i != m_connections.end(); ++i) { TORRENT_ASSERT(*i); - boost::shared_ptr t = (*i)->associated_torrent().lock(); + std::shared_ptr t = (*i)->associated_torrent().lock(); TORRENT_ASSERT(unique_peers.find(i->get()) == unique_peers.end()); unique_peers.insert(i->get()); diff --git a/src/storage.cpp b/src/storage.cpp index 80d28672c..297029efd 100644 --- a/src/storage.cpp +++ b/src/storage.cpp @@ -1477,7 +1477,7 @@ namespace libtorrent piece_manager::piece_manager( storage_interface* storage_impl - , boost::shared_ptr const& torrent + , std::shared_ptr const& torrent , file_storage* files) : m_files(*files) , m_storage(storage_impl) diff --git a/src/torrent.cpp b/src/torrent.cpp index ed7f89bd2..d589d7134 100644 --- a/src/torrent.cpp +++ b/src/torrent.cpp @@ -441,7 +441,7 @@ namespace libtorrent // as we replace the torrent_info object // we're about to erase the session's reference to this // torrent, create another reference - boost::shared_ptr me(shared_from_this()); + std::shared_ptr me(shared_from_this()); m_ses.remove_torrent_impl(me, 0); @@ -452,7 +452,7 @@ namespace libtorrent m_info_hash = tf->info_hash(); // now, we might already have this torrent in the session. - boost::shared_ptr t = m_ses.find_torrent(m_torrent_file->info_hash()).lock(); + std::shared_ptr t = m_ses.find_torrent(m_torrent_file->info_hash()).lock(); if (t) { if (!m_uuid.empty() && t->uuid().empty()) @@ -1896,7 +1896,7 @@ namespace libtorrent for (std::vector::iterator i = s.begin(), end(s.end()); i != end; ++i) { - boost::shared_ptr t = m_ses.find_torrent(*i).lock(); + std::shared_ptr t = m_ses.find_torrent(*i).lock(); if (!t) continue; // Only attempt to reuse files from torrents that are seeding. @@ -1910,9 +1910,9 @@ namespace libtorrent for (std::vector::iterator i = c.begin(), end(c.end()); i != end; ++i) { - std::vector > ts = m_ses.find_collection(*i); + std::vector > ts = m_ses.find_collection(*i); - for (std::vector >::iterator k = ts.begin() + for (std::vector >::iterator k = ts.begin() , end2(ts.end()); k != end2; ++k) { // Only attempt to reuse files from torrents that are seeding. @@ -2667,11 +2667,11 @@ namespace libtorrent } #endif - void torrent::on_tracker_announce_disp(boost::weak_ptr p + void torrent::on_tracker_announce_disp(std::weak_ptr p , error_code const& e) { COMPLETE_ASYNC("tracker::on_tracker_announce_disp"); - boost::shared_ptr t = p.lock(); + std::shared_ptr t = p.lock(); if (!t) return; t->m_waiting_tracker = false; @@ -2797,16 +2797,16 @@ namespace libtorrent if (settings().get_bool(settings_pack::enable_incoming_utp)) flags |= dht::dht_tracker::flag_implied_port; - boost::weak_ptr self(shared_from_this()); + std::weak_ptr self(shared_from_this()); m_ses.dht()->announce(m_torrent_file->info_hash() , port, flags , std::bind(&torrent::on_dht_announce_response_disp, self, _1)); } - void torrent::on_dht_announce_response_disp(boost::weak_ptr t + void torrent::on_dht_announce_response_disp(std::weak_ptr t , std::vector const& peers) { - boost::shared_ptr tor = t.lock(); + std::shared_ptr tor = t.lock(); if (!tor) return; tor->on_dht_announce_response(peers); } @@ -3044,7 +3044,7 @@ namespace libtorrent // observer object just for logging if (m_abort && alerts().should_post()) { - boost::shared_ptr tl(new aux::tracker_logger(m_ses)); + std::shared_ptr tl(new aux::tracker_logger(m_ses)); m_ses.queue_tracker_request(req, tl); } else @@ -9153,7 +9153,7 @@ namespace libtorrent m_waiting_tracker = true; error_code ec; - boost::weak_ptr self(shared_from_this()); + std::weak_ptr self(shared_from_this()); ADD_OUTSTANDING_ASYNC("tracker::on_tracker_announce_disp"); m_tracker_timer.expires_at(next_announce, ec); @@ -9276,10 +9276,10 @@ namespace libtorrent TORRENT_ASSERT(is_single_thread()); INVARIANT_CHECK; - boost::weak_ptr self(shared_from_this()); + std::weak_ptr self(shared_from_this()); #ifndef TORRENT_DISABLE_EXTENSIONS - for (auto& ext : m_extensions) + for (auto const& ext : m_extensions) { TORRENT_TRY { ext->tick(); diff --git a/src/torrent_handle.cpp b/src/torrent_handle.cpp index b34589289..a6f4cce43 100644 --- a/src/torrent_handle.cpp +++ b/src/torrent_handle.cpp @@ -69,7 +69,7 @@ namespace libtorrent template void torrent_handle::async_call(Fun f, Args&&... a) const { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT_PRECOND(t); if (!t) return; session_impl& ses = static_cast(t->session()); @@ -79,7 +79,7 @@ namespace libtorrent template void torrent_handle::sync_call(Fun f, Args&&... a) const { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT_PRECOND(t); if (!t) return; session_impl& ses = static_cast(t->session()); @@ -101,7 +101,7 @@ namespace libtorrent template Ret torrent_handle::sync_call_ret(Ret def, Fun f, Args&&... a) const { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); TORRENT_ASSERT_PRECOND(t); Ret r = def; if (!t) return r; @@ -125,7 +125,7 @@ namespace libtorrent sha1_hash torrent_handle::info_hash() const { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); static const sha1_hash empty; if (!t) return empty; return t->info_hash(); @@ -650,7 +650,7 @@ namespace libtorrent { status.clear(); - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t || !t->has_storage()) return; session_impl& ses = static_cast(t->session()); status = ses.disk_thread().files().get_status(&t->storage()); @@ -671,7 +671,7 @@ namespace libtorrent std::vector torrent_handle::file_status() const { - boost::shared_ptr t = m_torrent.lock(); + std::shared_ptr t = m_torrent.lock(); if (!t || !t->has_storage()) return {}; session_impl& ses = static_cast(t->session()); return ses.disk_thread().files().get_status(&t->storage()); @@ -722,7 +722,7 @@ namespace libtorrent async_call(&torrent::clear_time_critical); } - boost::shared_ptr torrent_handle::native_handle() const + std::shared_ptr torrent_handle::native_handle() const { return m_torrent.lock(); } diff --git a/src/tracker_manager.cpp b/src/tracker_manager.cpp index 933240803..9c1cf1ac1 100644 --- a/src/tracker_manager.cpp +++ b/src/tracker_manager.cpp @@ -151,14 +151,14 @@ namespace libtorrent tracker_manager& man , tracker_request const& req , io_service& ios - , boost::weak_ptr r) + , std::weak_ptr r) : timeout_handler(ios) , m_req(req) , m_requester(std::move(r)) , m_man(man) {} - boost::shared_ptr tracker_connection::requester() const + std::shared_ptr tracker_connection::requester() const { return m_requester.lock(); } @@ -174,7 +174,7 @@ namespace libtorrent void tracker_connection::fail_impl(error_code const& ec, int code , std::string msg, int interval, int min_interval) { - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) cb->tracker_request_error(m_req, code, ec, msg.c_str() , interval == 0 ? min_interval : interval); close(); @@ -266,7 +266,7 @@ namespace libtorrent void tracker_manager::queue_request( io_service& ios , tracker_request req - , boost::weak_ptr c) + , std::weak_ptr c) { TORRENT_ASSERT(is_single_thread()); TORRENT_ASSERT(req.num_want >= 0); @@ -305,7 +305,7 @@ namespace libtorrent } // we need to post the error to avoid deadlock - if (boost::shared_ptr r = c.lock()) + if (std::shared_ptr r = c.lock()) ios.post(std::bind(&request_callback::tracker_request_error, r, req , -1, error_code(errors::unsupported_url_protocol) , "", 0)); @@ -425,7 +425,7 @@ namespace libtorrent close_http_connections.push_back(*i); #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr rc = c->requester(); + std::shared_ptr rc = c->requester(); if (rc) rc->debug_log("aborting: %s", req.url.c_str()); #endif } @@ -440,7 +440,7 @@ namespace libtorrent close_udp_connections.push_back(c); #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr rc = c->requester(); + std::shared_ptr rc = c->requester(); if (rc) rc->debug_log("aborting: %s", req.url.c_str()); #endif } diff --git a/src/udp_tracker_connection.cpp b/src/udp_tracker_connection.cpp index ea8848050..a88a8e6b3 100644 --- a/src/udp_tracker_connection.cpp +++ b/src/udp_tracker_connection.cpp @@ -73,7 +73,7 @@ namespace libtorrent io_service& ios , tracker_manager& man , tracker_request const& req - , boost::weak_ptr c) + , std::weak_ptr c) : tracker_connection(man, req, ios, c) , m_transaction_id(0) , m_attempts(0) @@ -126,7 +126,7 @@ namespace libtorrent , shared_from_this(), _1, _2, port)); #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) cb->debug_log("*** UDP_TRACKER [ initiating name lookup: \"%s\" ]" , hostname.c_str()); #endif @@ -155,7 +155,7 @@ namespace libtorrent } #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) cb->debug_log("*** UDP_TRACKER [ host: \"%s\" ip: \"%s\" | error: \"%s\" ]" , m_hostname.c_str(), print_endpoint(m_target).c_str(), ec.message().c_str()); #endif @@ -189,7 +189,7 @@ namespace libtorrent return; } - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); #ifndef TORRENT_DISABLE_LOGGING if (cb) cb->debug_log("*** UDP_TRACKER [ name lookup successful ]"); #endif @@ -254,7 +254,7 @@ namespace libtorrent if (iter == m_endpoints.end()) { TORRENT_ASSERT(target.address().is_v4() != bind_interface().is_v4()); - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) { char const* tracker_address_type = target.address().is_v4() ? "IPv4" : "IPv6"; @@ -312,7 +312,7 @@ namespace libtorrent } #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) cb->debug_log("*** UDP_TRACKER [ timed out url: %s ]", tracker_req().url.c_str()); #endif fail(error_code(errors::timed_out)); @@ -339,7 +339,7 @@ namespace libtorrent , span const buf) { #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); #endif // ignore resposes before we've sent any requests @@ -479,7 +479,7 @@ namespace libtorrent void udp_tracker_connection::send_udp_connect() { #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); #endif if (m_abort) @@ -606,7 +606,7 @@ namespace libtorrent return false; } - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); #ifndef TORRENT_DISABLE_LOGGING if (cb) { @@ -682,7 +682,7 @@ namespace libtorrent int const downloaded = aux::read_int32(buf); int const incomplete = aux::read_int32(buf); - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (!cb) { close(); @@ -757,7 +757,7 @@ namespace libtorrent } #ifndef TORRENT_DISABLE_LOGGING - boost::shared_ptr cb = requester(); + std::shared_ptr cb = requester(); if (cb) { char hex_ih[41]; diff --git a/src/web_connection_base.cpp b/src/web_connection_base.cpp index 13673f123..654762f64 100644 --- a/src/web_connection_base.cpp +++ b/src/web_connection_base.cpp @@ -109,7 +109,7 @@ namespace libtorrent void web_connection_base::on_connected() { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); // this is always a seed diff --git a/src/web_peer_connection.cpp b/src/web_peer_connection.cpp index 89677d897..d8a7e775a 100644 --- a/src/web_peer_connection.cpp +++ b/src/web_peer_connection.cpp @@ -85,7 +85,7 @@ web_peer_connection::web_peer_connection(peer_connection_args const& pack if (!m_settings.get_bool(settings_pack::report_web_seed_downloads)) ignore_stats(true); - shared_ptr tor = pack.tor.lock(); + std::shared_ptr tor = pack.tor.lock(); TORRENT_ASSERT(tor); // we always prefer downloading 1 MiB chunks @@ -99,7 +99,7 @@ web_peer_connection::web_peer_connection(peer_connection_args const& pack prefer_contiguous_blocks((std::max)(preferred_size / tor->block_size(), 1)); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); bool const single_file_request = t->torrent_file().num_files() == 1; if (!single_file_request) @@ -186,7 +186,7 @@ void web_peer_connection::disconnect(error_code const& ec m_web->endpoints.erase(m_web->endpoints.begin()); } - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); if (!m_requests.empty() && !m_file_requests.empty() && !m_piece.empty() && m_web) @@ -230,7 +230,7 @@ web_peer_connection::downloading_piece_progress() const if (m_requests.empty()) return boost::optional(); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); piece_block_progress ret; @@ -257,7 +257,7 @@ void web_peer_connection::write_request(peer_request const& r) { INVARIANT_CHECK; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); TORRENT_ASSERT(t->valid_metadata()); @@ -504,7 +504,7 @@ bool web_peer_connection::received_invalid_data(int index, bool single_peer) // 3. if it's a single file torrent, just ban it right away // this handles the case where web seeds may have some files updated but not other - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); file_storage const& fs = t->torrent_file().files(); // single file torrent @@ -544,7 +544,7 @@ void web_peer_connection::on_receive_padfile() void web_peer_connection::handle_error(int bytes_left) { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); // TODO: 2 just make this peer not have the pieces @@ -573,7 +573,7 @@ void web_peer_connection::handle_redirect(int bytes_left) std::string location = m_parser.header("location"); received_bytes(0, bytes_left); - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); if (location.empty()) @@ -648,7 +648,7 @@ void web_peer_connection::on_receive(error_code const& error return; } - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); // in case the first file on this series of requests is a padfile @@ -967,7 +967,7 @@ void web_peer_connection::incoming_payload(char const* buf, int len) TORRENT_ASSERT(front_request.length >= piece_size); if (int(m_piece.size()) == front_request.length) { - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_LOGGING @@ -1019,7 +1019,7 @@ void web_peer_connection::maybe_harvest_piece() TORRENT_ASSERT(front_request.length >= int(m_piece.size())); if (int(m_piece.size()) != front_request.length) return; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_LOGGING @@ -1045,7 +1045,7 @@ void web_peer_connection::handle_padfile() if (m_file_requests.empty()) return; if (m_requests.empty()) return; - boost::shared_ptr t = associated_torrent().lock(); + std::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); torrent_info const& info = t->torrent_file(); diff --git a/test/test_block_cache.cpp b/test/test_block_cache.cpp index 4c1a74112..b3ef7eed7 100644 --- a/test/test_block_cache.cpp +++ b/test/test_block_cache.cpp @@ -101,7 +101,7 @@ static void nop() {} fs.set_piece_length(0x8000); \ fs.set_num_pieces(5); \ test_storage_impl* st = new test_storage_impl; \ - std::shared_ptr pm = std::make_shared(st, boost::shared_ptr(new int), &fs); \ + std::shared_ptr pm = std::make_shared(st, std::shared_ptr(new int), &fs); \ error_code ec; \ bc.set_settings(sett, ec); \ st->m_settings = &sett; \ diff --git a/test/test_storage.cpp b/test/test_storage.cpp index 7174dc277..529316e28 100644 --- a/test/test_storage.cpp +++ b/test/test_storage.cpp @@ -462,7 +462,7 @@ void test_check_files(std::string const& test_path p.pool = &fp; p.mode = storage_mode; - boost::shared_ptr dummy; + std::shared_ptr dummy; std::shared_ptr pm = std::make_shared(new default_storage(p), dummy, &fs); std::mutex lock;