wornvirtue
/
premiere-libtorrent
forked from premiere/premiere-libtorrent
1
0
Fork 0
Code Pull Requests Activity

more use of std::shared_ptr refactor

This commit is contained in:
Alden Torres 2016-08-29 08:31:23 -04:00
parent 2ac45d17ef
commit e2487c4d24
30 changed files with 97 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/libtorrent/aux_/session_impl.hpp
View File

@ -1009,7 +1009,7 @@ namespace libtorrent
#ifndef TORRENT_DISABLE_DHT
std::unique_ptr<dht::dht_storage_interface> m_dht_storage;
boost::shared_ptr<dht::dht_tracker> m_dht;
std::shared_ptr<dht::dht_tracker> m_dht;
dht_settings m_dht_settings;
dht::dht_storage_constructor_type m_dht_storage_constructor
= dht::dht_default_storage_constructor;
@ -1068,9 +1068,9 @@ namespace libtorrent
// this is deducted from the connect speed
int m_boost_connections = 0;
boost::shared_ptr<natpmp> m_natpmp;
boost::shared_ptr<upnp> m_upnp;
boost::shared_ptr<lsd> m_lsd;
std::shared_ptr<natpmp> m_natpmp;
std::shared_ptr<upnp> m_upnp;
std::shared_ptr<lsd> m_lsd;
// mask is a bitmask of which protocols to remap on:
// 1: NAT-PMP

10
include/libtorrent/block_cache.hpp
View File

@ -36,14 +36,14 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/unordered_set.hpp>
#include <cstdint>
#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>
#include <list>
#include <vector>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
#include <cstdint>
#include <list>
#include <vector>
#include "libtorrent/time.hpp"
#include "libtorrent/error_code.hpp"
#include "libtorrent/io_service_fwd.hpp"
@ -187,7 +187,7 @@ namespace libtorrent
}
// storage this piece belongs to
boost::shared_ptr<piece_manager> storage;
std::shared_ptr<piece_manager> storage;
// write jobs hanging off of this piece
tailqueue<disk_io_job> jobs;

16
include/libtorrent/disk_io_job.hpp
View File

@ -33,26 +33,18 @@ POSSIBILITY OF SUCH DAMAGE.
#ifndef TORRENT_DISK_IO_JOB_HPP
#define TORRENT_DISK_IO_JOB_HPP
#include "libtorrent/time.hpp"
#include "libtorrent/error_code.hpp"
#include "libtorrent/tailqueue.hpp"
#include "libtorrent/peer_id.hpp"
#include <string>
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/function/function1.hpp>
#include <boost/shared_ptr.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
#include <vector>
#include <memory>
#include <functional>
namespace libtorrent
{
class entry;
class piece_manager;
struct cached_piece_entry;
struct bdecode_node;
class torrent_info;
struct add_torrent_params;
@ -161,7 +153,7 @@ namespace libtorrent
} buffer;
// the disk storage this job applies to (if applicable)
boost::shared_ptr<piece_manager> storage;
std::shared_ptr<piece_manager> storage;
// this is called when operation completes
std::function<void(disk_io_job const*)> callback;

4
include/libtorrent/http_tracker_connection.hpp
View File

@ -77,9 +77,9 @@ namespace libtorrent
private:
boost::shared_ptr<http_tracker_connection> shared_from_this()
std::shared_ptr<http_tracker_connection> shared_from_this()
{
return boost::static_pointer_cast<http_tracker_connection>(
return std::static_pointer_cast<http_tracker_connection>(
tracker_connection::shared_from_this());
}

5
include/libtorrent/kademlia/dht_tracker.hpp
View File

@ -36,7 +36,6 @@ POSSIBILITY OF SUCH DAMAGE.
#define TORRENT_DHT_TRACKER
#include <functional>
#include <boost/smart_ptr/enable_shared_from_this.hpp>
#include "libtorrent/kademlia/node.hpp"
#include "libtorrent/kademlia/node_id.hpp"
@ -63,7 +62,7 @@ namespace libtorrent { namespace dht
struct TORRENT_EXTRA_EXPORT dht_tracker final
: udp_socket_interface
, boost::enable_shared_from_this<dht_tracker>
, std::enable_shared_from_this<dht_tracker>
{
typedef std::function<void(udp::endpoint const&
, span<char const>, error_code&, int)> send_fun_t;
@ -134,7 +133,7 @@ namespace libtorrent { namespace dht
private:
boost::shared_ptr<dht_tracker> self()
std::shared_ptr<dht_tracker> self()
{ return shared_from_this(); }
void connection_timeout(node& n, error_code const& e);

19
include/libtorrent/lsd.hpp
View File

@ -38,19 +38,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/broadcast_socket.hpp"
#include "libtorrent/deadline_timer.hpp"
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/function/function2.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#ifndef TORRENT_DISABLE_LOGGING
#include <boost/function/function1.hpp>
#endif
#include "libtorrent/aux_/disable_warnings_pop.hpp"
namespace libtorrent
{
@ -59,7 +46,7 @@ typedef std::function<void(tcp::endpoint, sha1_hash)> peer_callback_t;
typedef std::function<void(char const*)> log_callback_t;
#endif
class lsd : public boost::enable_shared_from_this<lsd>
class lsd : public std::enable_shared_from_this<lsd>
{
public:
lsd(io_service& ios, peer_callback_t const& cb
@ -76,7 +63,7 @@ public:
private:
boost::shared_ptr<lsd> self() { return shared_from_this(); }
std::shared_ptr<lsd> self() { return shared_from_this(); }
void announce_impl(sha1_hash const& ih, int listen_port
, bool broadcast, int retry_count);
@ -117,6 +104,4 @@ private:
}
#endif

14
include/libtorrent/natpmp.hpp
View File

@ -41,14 +41,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/time.hpp"
#include "libtorrent/debug.hpp"
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/function/function1.hpp>
#include <boost/function/function5.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
namespace libtorrent
{
@ -59,7 +51,7 @@ typedef std::function<void(int, address, int, int, error_code const&)> portmap_c
typedef std::function<void(char const*)> log_callback_t;
struct TORRENT_EXTRA_EXPORT natpmp
: boost::enable_shared_from_this<natpmp>
: std::enable_shared_from_this<natpmp>
, single_threaded
{
natpmp(io_service& ios, portmap_callback_t const& cb
@ -78,7 +70,7 @@ struct TORRENT_EXTRA_EXPORT natpmp
private:
boost::shared_ptr<natpmp> self() { return shared_from_this(); }
std::shared_ptr<natpmp> self() { return shared_from_this(); }
void update_mapping(int i);
void send_map_request(int i);
@ -182,6 +174,4 @@ private:
}
#endif

2
include/libtorrent/receive_buffer.hpp
View File

@ -37,6 +37,8 @@ POSSIBILITY OF SUCH DAMAGE.
#include <libtorrent/disk_buffer_holder.hpp>
#include <libtorrent/sliding_average.hpp>
#include <climits>
namespace libtorrent {
struct TORRENT_EXTRA_EXPORT receive_buffer

5
include/libtorrent/storage.hpp
View File

@ -43,10 +43,7 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <sys/types.h>
#include <boost/function/function2.hpp>
#include <boost/function/function0.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
@ -554,7 +551,7 @@ namespace libtorrent
};
class TORRENT_EXTRA_EXPORT piece_manager
: public boost::enable_shared_from_this<piece_manager>
: public std::enable_shared_from_this<piece_manager>
, public disk_job_fence
, public storage_piece_set
, boost::noncopyable

2
include/libtorrent/torrent.hpp
View File

@ -1167,7 +1167,7 @@ namespace libtorrent
// the piece_manager, and stored in the
// torrent, so the torrent cannot destruct
// before the piece_manager.
boost::shared_ptr<piece_manager> m_storage;
std::shared_ptr<piece_manager> m_storage;
#ifdef TORRENT_USE_OPENSSL
boost::shared_ptr<boost::asio::ssl::context> m_ssl_ctx;

15
include/libtorrent/tracker_manager.hpp
View File

@ -219,7 +219,7 @@ namespace libtorrent
int incomplete;
// if supported by the tracker, the number of actively downloading peers.
// i.e. partial seeds. If not suppored, -1
// i.e. partial seeds. If not supported, -1
int downloaders;
// the number of times the torrent has been downloaded
@ -254,7 +254,7 @@ namespace libtorrent
};
struct TORRENT_EXTRA_EXPORT timeout_handler
: boost::enable_shared_from_this<timeout_handler>
: std::enable_shared_from_this<timeout_handler>
, boost::noncopyable
{
timeout_handler(io_service& str);
@ -315,9 +315,9 @@ namespace libtorrent
void sent_bytes(int bytes);
void received_bytes(int bytes);
boost::shared_ptr<tracker_connection> shared_from_this()
std::shared_ptr<tracker_connection> shared_from_this()
{
return boost::static_pointer_cast<tracker_connection>(
return std::static_pointer_cast<tracker_connection>(
timeout_handler::shared_from_this());
}
@ -383,7 +383,7 @@ namespace libtorrent
bool incoming_packet(char const* hostname, span<char const> buf);
void update_transaction_id(
boost::shared_ptr<udp_tracker_connection> c
std::shared_ptr<udp_tracker_connection> c
, std::uint64_t tid);
aux::session_settings const& settings() const { return m_settings; }
@ -401,10 +401,10 @@ namespace libtorrent
// These must use shared_ptr to avoid a dangling reference
// if a connection is erased while a timeout event is in the queue
typedef boost::unordered_map<std::uint32_t
, boost::shared_ptr<udp_tracker_connection> > udp_conns_t;
, std::shared_ptr<udp_tracker_connection>> udp_conns_t;
udp_conns_t m_udp_conns;
typedef std::vector<boost::shared_ptr<http_tracker_connection> > http_conns_t;
typedef std::vector<std::shared_ptr<http_tracker_connection>> http_conns_t;
http_conns_t m_http_conns;
send_fun_t m_send_fun;
@ -421,4 +421,3 @@ namespace libtorrent
}
#endif // TORRENT_TRACKER_MANAGER_HPP_INCLUDED

3
include/libtorrent/udp_socket.hpp
View File

@ -141,7 +141,7 @@ namespace libtorrent
aux::proxy_settings m_proxy_settings;
boost::shared_ptr<socks5> m_socks5_connection;
std::shared_ptr<socks5> m_socks5_connection;
// TODO: 3 add a unit test for force-proxy
bool m_force_proxy:1;
@ -155,4 +155,3 @@ namespace libtorrent
}
#endif

4
include/libtorrent/udp_tracker_connection.hpp
View File

@ -80,9 +80,9 @@ namespace libtorrent
action_error
};
boost::shared_ptr<udp_tracker_connection> shared_from_this()
std::shared_ptr<udp_tracker_connection> shared_from_this()
{
return boost::static_pointer_cast<udp_tracker_connection>(
return std::static_pointer_cast<udp_tracker_connection>(
tracker_connection::shared_from_this());
}

5
include/libtorrent/upnp.hpp
View File

@ -44,7 +44,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
#include <functional>
@ -131,7 +130,7 @@ TORRENT_EXTRA_EXPORT void find_control_url(int type, char const* string
// TODO: support using the windows API for UPnP operations as well
struct TORRENT_EXTRA_EXPORT upnp final
: boost::enable_shared_from_this<upnp>
: std::enable_shared_from_this<upnp>
, single_threaded
{
upnp(io_service& ios
@ -182,7 +181,7 @@ struct TORRENT_EXTRA_EXPORT upnp final
private:
boost::shared_ptr<upnp> self() { return shared_from_this(); }
std::shared_ptr<upnp> self() { return shared_from_this(); }
void map_timer(error_code const& ec);
void try_map_upnp(bool timer = false);

4
src/create_torrent.cpp
View File

@ -161,7 +161,7 @@ namespace libtorrent
}
void on_hash(disk_io_job const* j, create_torrent* t
, boost::shared_ptr<piece_manager> storage, disk_io_thread* iothread
, std::shared_ptr<piece_manager> storage, disk_io_thread* iothread
, int* piece_counter, int* completed_piece
, std::function<void(int)> const* f, error_code* ec)
{
@ -282,7 +282,7 @@ namespace libtorrent
storage_interface* storage_impl = default_storage_constructor(params);
boost::shared_ptr<piece_manager> storage = boost::make_shared<piece_manager>(
std::shared_ptr<piece_manager> storage = std::make_shared<piece_manager>(
storage_impl, dummy, const_cast<file_storage*>(&t.files()));
settings_pack sett;

5
src/disk_io_job.cpp
View File

@ -31,9 +31,7 @@ POSSIBILITY OF SUCH DAMAGE.
*/
#include "libtorrent/disk_io_job.hpp"
#include "libtorrent/storage.hpp"
#include "libtorrent/block_cache.hpp" // for cached_piece_entry
#include "libtorrent/entry.hpp"
namespace libtorrent
{
@ -68,7 +66,7 @@ namespace libtorrent
{
if (action != write) return false;
int block_offset = d.io.offset & (block_size-1);
int block_offset = d.io.offset & (block_size - 1);
int size = d.io.buffer_size;
int start = d.io.offset / block_size;
int end = block_offset > 0 && (size > block_size - block_offset) ? start + 2 : start + 1;
@ -81,4 +79,3 @@ namespace libtorrent
return true;
}
}

2
src/disk_io_thread.cpp
View File

@ -1074,7 +1074,7 @@ namespace libtorrent
}
#endif
boost::shared_ptr<piece_manager> storage = j->storage;
std::shared_ptr<piece_manager> storage = j->storage;
// TODO: instead of doing this. pass in the settings to each storage_interface
// call. Each disk thread could hold its most recent understanding of the settings

2
src/http_tracker_connection.cpp
View File

@ -297,7 +297,7 @@ namespace libtorrent
, http_parser const& parser, char const* data, int size)
{
// keep this alive
boost::shared_ptr<http_tracker_connection> me(shared_from_this());
std::shared_ptr<http_tracker_connection> me(shared_from_this());
if (ec && ec != boost::asio::error::eof)
{

32
src/kademlia/dht_tracker.cpp
View File

@ -56,14 +56,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/hex.hpp" // to_hex
#endif
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <functional>
#include <boost/function/function0.hpp>
#include <boost/ref.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
using libtorrent::dht::node;
using libtorrent::dht::node_id;
using libtorrent::dht::packet_t;
@ -363,7 +355,7 @@ namespace libtorrent { namespace dht
// these functions provide a slightly higher level
// interface to the get/put functionality in the DHT
void get_immutable_item_callback(item const& it, boost::shared_ptr<get_immutable_item_ctx> ctx
void get_immutable_item_callback(item const& it, std::shared_ptr<get_immutable_item_ctx> ctx
, std::function<void(item const&)> f)
{
// the reason to wrap here is to control the return value
@ -385,7 +377,7 @@ namespace libtorrent { namespace dht
};
void get_mutable_item_callback(item const& it, bool authoritative
, boost::shared_ptr<get_mutable_item_ctx> ctx
, std::shared_ptr<get_mutable_item_ctx> ctx
, std::function<void(item const&, bool)> f)
{
TORRENT_ASSERT(it.is_mutable());
@ -411,7 +403,7 @@ namespace libtorrent { namespace dht
int response_count;
};
void put_immutable_item_callback(int responses, boost::shared_ptr<put_item_ctx> ctx
void put_immutable_item_callback(int responses, std::shared_ptr<put_item_ctx> ctx
, std::function<void(int)> f)
{
ctx->response_count += responses;
@ -419,7 +411,7 @@ namespace libtorrent { namespace dht
f(ctx->response_count);
}
void put_mutable_item_callback(item const& it, int responses, boost::shared_ptr<put_item_ctx> ctx
void put_mutable_item_callback(item const& it, int responses, std::shared_ptr<put_item_ctx> ctx
, std::function<void(item const&, int)> cb)
{
ctx->response_count += responses;
@ -432,8 +424,8 @@ namespace libtorrent { namespace dht
void dht_tracker::get_item(sha1_hash const& target
, std::function<void(item const&)> cb)
{
boost::shared_ptr<get_immutable_item_ctx>
ctx = boost::make_shared<get_immutable_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
std::shared_ptr<get_immutable_item_ctx>
ctx = std::make_shared<get_immutable_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
m_dht.get_item(target, std::bind(&get_immutable_item_callback, _1, ctx, cb));
#if TORRENT_USE_IPV6
m_dht6.get_item(target, std::bind(&get_immutable_item_callback, _1, ctx, cb));
@ -446,8 +438,8 @@ namespace libtorrent { namespace dht
, std::function<void(item const&, bool)> cb
, std::string salt)
{
boost::shared_ptr<get_mutable_item_ctx>
ctx = boost::make_shared<get_mutable_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
std::shared_ptr<get_mutable_item_ctx>
ctx = std::make_shared<get_mutable_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
m_dht.get_item(key, salt, std::bind(&get_mutable_item_callback, _1, _2, ctx, cb));
#if TORRENT_USE_IPV6
m_dht6.get_item(key, salt, std::bind(&get_mutable_item_callback, _1, _2, ctx, cb));
@ -461,8 +453,8 @@ namespace libtorrent { namespace dht
bencode(std::back_inserter(flat_data), data);
sha1_hash const target = item_target_id(flat_data);
boost::shared_ptr<put_item_ctx>
ctx = boost::make_shared<put_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
std::shared_ptr<put_item_ctx>
ctx = std::make_shared<put_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
m_dht.put_item(target, data, std::bind(&put_immutable_item_callback
, _1, ctx, cb));
#if TORRENT_USE_IPV6
@ -475,8 +467,8 @@ namespace libtorrent { namespace dht
, std::function<void(item const&, int)> cb
, std::function<void(item&)> data_cb, std::string salt)
{
boost::shared_ptr<put_item_ctx>
ctx = boost::make_shared<put_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
std::shared_ptr<put_item_ctx>
ctx = std::make_shared<put_item_ctx>((TORRENT_USE_IPV6) ? 2 : 1);
m_dht.put_item(key, salt, std::bind(&put_mutable_item_callback
, _1, _2, ctx, cb), data_cb);

2
src/lsd.cpp
View File

@ -311,5 +311,3 @@ void lsd::close()
}
} // libtorrent namespace

2
src/natpmp.cpp
View File

@ -37,7 +37,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include <pthread.h>
#endif
#include <boost/version.hpp>
#include <boost/asio/ip/host_name.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
@ -657,4 +656,3 @@ void natpmp::close_impl()
m_currently_mapping = -1;
update_mapping(0);
}

10
src/session_impl.cpp
View File

@ -5521,11 +5521,11 @@ namespace aux {
if (m_outstanding_router_lookups > 0) return;
m_dht_storage = m_dht_storage_constructor(m_dht_settings);
m_dht = boost::make_shared<dht::dht_tracker>(
m_dht = std::make_shared<dht::dht_tracker>(
static_cast<dht_observer*>(this)
, std::ref(m_io_service)
, std::bind(&session_impl::send_udp_packet, this, false, _1, _2, _3, _4)
, boost::cref(m_dht_settings)
, std::cref(m_dht_settings)
, std::ref(m_stats_counters)
, *m_dht_storage
, startup_state);
@ -6390,7 +6390,7 @@ namespace aux {
if (m_lsd) return;
m_lsd = boost::make_shared<lsd>(std::ref(m_io_service)
m_lsd = std::make_shared<lsd>(std::ref(m_io_service)
, std::bind(&session_impl::on_lsd_peer, this, _1, _2)
#ifndef TORRENT_DISABLE_LOGGING
, std::bind(&session_impl::on_lsd_log, this, _1)
@ -6418,7 +6418,7 @@ namespace aux {
// the natpmp constructor may fail and call the callbacks
// into the session_impl.
m_natpmp = boost::make_shared<natpmp>(std::ref(m_io_service)
m_natpmp = std::make_shared<natpmp>(std::ref(m_io_service)
, std::bind(&session_impl::on_port_mapping
, this, _1, _2, _3, _4, _5, 0)
, std::bind(&session_impl::on_port_map_log
@ -6440,7 +6440,7 @@ namespace aux {
if (m_upnp) return m_upnp.get();
// the upnp constructor may fail and call the callbacks
m_upnp = boost::make_shared<upnp>(std::ref(m_io_service)
m_upnp = std::make_shared<upnp>(std::ref(m_io_service)
, m_settings.get_str(settings_pack::user_agent)
, std::bind(&session_impl::on_port_mapping
, this, _1, _2, _3, _4, _5, 1)

2
src/torrent.cpp
View File

@ -1675,7 +1675,7 @@ namespace libtorrent
// the shared_from_this() will create an intentional
// cycle of ownership, se the hpp file for description.
m_storage = boost::make_shared<piece_manager>(
m_storage = std::make_shared<piece_manager>(
storage_impl, shared_from_this()
, const_cast<file_storage*>(&m_torrent_file->files()));
}

30
src/tracker_manager.cpp
View File

@ -238,7 +238,7 @@ namespace libtorrent
{
TORRENT_ASSERT(is_single_thread());
http_conns_t::iterator i = std::find_if(m_http_conns.begin(), m_http_conns.end()
, [c] (boost::shared_ptr<http_tracker_connection> const& ptr) { return ptr.get() == c; });
, [c] (std::shared_ptr<http_tracker_connection> const& ptr) { return ptr.get() == c; });
if (i != m_http_conns.end())
{
m_http_conns.erase(i);
@ -255,7 +255,7 @@ namespace libtorrent
}
void tracker_manager::update_transaction_id(
boost::shared_ptr<udp_tracker_connection> c
std::shared_ptr<udp_tracker_connection> c
, std::uint64_t tid)
{
TORRENT_ASSERT(is_single_thread());
@ -287,18 +287,18 @@ namespace libtorrent
if (protocol == "http")
#endif
{
boost::shared_ptr<http_tracker_connection> con
= boost::make_shared<http_tracker_connection>(
std::ref(ios), std::ref(*this), boost::cref(req), c);
std::shared_ptr<http_tracker_connection> con
= std::make_shared<http_tracker_connection>(
std::ref(ios), std::ref(*this), std::cref(req), c);
m_http_conns.push_back(con);
con->start();
return;
}
else if (protocol == "udp")
{
boost::shared_ptr<udp_tracker_connection> con
= boost::make_shared<udp_tracker_connection>(
std::ref(ios), std::ref(*this), boost::cref(req) , c);
std::shared_ptr<udp_tracker_connection> con
= std::make_shared<udp_tracker_connection>(
std::ref(ios), std::ref(*this), std::cref(req) , c);
m_udp_conns[con->transaction_id()] = con;
con->start();
return;
@ -344,7 +344,7 @@ namespace libtorrent
return false;
}
boost::shared_ptr<udp_tracker_connection> const p = i->second;
std::shared_ptr<udp_tracker_connection> const p = i->second;
// on_receive() may remove the tracker connection from the list
return p->on_receive(ep, buf);
}
@ -383,7 +383,7 @@ namespace libtorrent
return false;
}
boost::shared_ptr<udp_tracker_connection> const p = i->second;
std::shared_ptr<udp_tracker_connection> const p = i->second;
// on_receive() may remove the tracker connection from the list
return p->on_receive_hostname(hostname, buf);
}
@ -412,7 +412,7 @@ namespace libtorrent
m_abort = true;
http_conns_t close_http_connections;
std::vector<boost::shared_ptr<udp_tracker_connection> > close_udp_connections;
std::vector<std::shared_ptr<udp_tracker_connection>> close_udp_connections;
for (http_conns_t::iterator i = m_http_conns.begin()
, end(m_http_conns.end()); i != end; ++i)
@ -432,7 +432,7 @@ namespace libtorrent
for (udp_conns_t::iterator i = m_udp_conns.begin()
, end(m_udp_conns.end()); i != end; ++i)
{
boost::shared_ptr<udp_tracker_connection> c = i->second;
std::shared_ptr<udp_tracker_connection> c = i->second;
tracker_request const& req = c->tracker_req();
if (req.event == tracker_request::stopped && !all)
continue;
@ -451,11 +451,9 @@ namespace libtorrent
(*i)->close();
}
for (std::vector<boost::shared_ptr<udp_tracker_connection> >::iterator i
= close_udp_connections.begin()
, end(close_udp_connections.end()); i != end; ++i)
for (auto const& c : close_udp_connections)
{
(*i)->close();
c->close();
}
}

13
src/udp_socket.cpp
View File

@ -41,12 +41,11 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/debug.hpp"
#include <cstdlib>
#include <functional>
#include <array>
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <functional>
#include <array>
#include <boost/function/function3.hpp>
#include <boost/system/system_error.hpp>
#include <boost/system/error_code.hpp>
#include <boost/asio/read.hpp>
@ -66,7 +65,7 @@ using namespace std::placeholders;
// been destructed, it needs to be held by a shared_ptr
// 2. since using a socks proxy is assumed to be a less common case, it makes
// the common case cheaper by not allocating this space unconditionally
struct socks5 : boost::enable_shared_from_this<socks5>
struct socks5 : std::enable_shared_from_this<socks5>
{
explicit socks5(io_service& ios)
: m_socks5_sock(ios)
@ -75,7 +74,7 @@ struct socks5 : boost::enable_shared_from_this<socks5>
, m_abort(false)
, m_active(false)
{
memset(m_tmp_buf, 0, sizeof(m_tmp_buf));
std::memset(m_tmp_buf, 0, sizeof(m_tmp_buf));
}
void start(aux::proxy_settings const& ps);
@ -86,7 +85,7 @@ struct socks5 : boost::enable_shared_from_this<socks5>
private:
boost::shared_ptr<socks5> self() { return shared_from_this(); }
std::shared_ptr<socks5> self() { return shared_from_this(); }
void on_name_lookup(error_code const& e, tcp::resolver::iterator i);
void on_connect_timeout(error_code const& ec);
@ -478,7 +477,7 @@ void udp_socket::set_proxy_settings(aux::proxy_settings const& ps)
{
// connect to socks5 server and open up the UDP tunnel
m_socks5_connection = boost::make_shared<socks5>(std::ref(m_socket.get_io_service()));
m_socks5_connection = std::make_shared<socks5>(std::ref(m_socket.get_io_service()));
m_socks5_connection->start(ps);
}
}

16
src/upnp.cpp
View File

@ -43,7 +43,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/debug.hpp"
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/ref.hpp>
#include <boost/asio/ip/host_name.hpp>
#include <boost/asio/ip/multicast.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
@ -274,7 +273,7 @@ void upnp::resend_request(error_code const& ec)
COMPLETE_ASYNC("upnp::resend_request");
if (ec) return;
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
if (m_closing) return;
@ -332,7 +331,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
, std::size_t bytes_transferred)
{
TORRENT_ASSERT(is_single_thread());
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
using namespace libtorrent::detail;
@ -739,7 +738,7 @@ void upnp::update_map(rootdevice& d, int i)
if (d.upnp_connection) return;
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
mapping_t& m = d.mapping[i];
@ -900,7 +899,7 @@ void upnp::on_upnp_xml(error_code const& e
, http_connection& c)
{
TORRENT_ASSERT(is_single_thread());
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
TORRENT_ASSERT(d.magic == 1337);
if (d.upnp_connection && d.upnp_connection.get() == &c)
@ -1181,7 +1180,7 @@ void upnp::on_upnp_get_ip_address_response(error_code const& e
, http_connection& c)
{
TORRENT_ASSERT(is_single_thread());
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
TORRENT_ASSERT(d.magic == 1337);
if (d.upnp_connection && d.upnp_connection.get() == &c)
@ -1267,7 +1266,7 @@ void upnp::on_upnp_map_response(error_code const& e
, http_connection& c)
{
TORRENT_ASSERT(is_single_thread());
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
TORRENT_ASSERT(d.magic == 1337);
if (d.upnp_connection && d.upnp_connection.get() == &c)
@ -1434,7 +1433,7 @@ void upnp::on_upnp_unmap_response(error_code const& e
, http_connection& c)
{
TORRENT_ASSERT(is_single_thread());
boost::shared_ptr<upnp> me(self());
std::shared_ptr<upnp> me(self());
TORRENT_ASSERT(d.magic == 1337);
if (d.upnp_connection && d.upnp_connection.get() == &c)
@ -1562,4 +1561,3 @@ void upnp::close()
}
}

15
test/test_bandwidth_limiter.cpp
View File

@ -43,7 +43,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "libtorrent/aux_/disable_warnings_pop.hpp"
#include <cmath>
@ -117,7 +116,7 @@ void peer_connection::start()
}
typedef std::vector<boost::shared_ptr<peer_connection> > connections_t;
typedef std::vector<boost::shared_ptr<peer_connection>> connections_t;
void do_change_rate(bandwidth_channel& t1, bandwidth_channel& t2, int limit)
{
@ -184,7 +183,7 @@ void spawn_connections(connections_t& v, bandwidth_manager& bwm
{
char name[200];
std::snprintf(name, sizeof(name), "%s%d", prefix, i);
v.push_back(boost::shared_ptr<peer_connection>(new peer_connection(bwm, bwc, 200, false, name)));
v.push_back(boost::make_shared<peer_connection>(bwm, bwc, 200, false, name));
}
}
@ -404,8 +403,8 @@ void test_peer_priority(int limit, bool torrent_limit)
spawn_connections(v1, manager, t1, 10, "p");
connections_t v;
std::copy(v1.begin(), v1.end(), std::back_inserter(v));
boost::shared_ptr<peer_connection> p(
new peer_connection(manager, t1, 1, false, "no-priority"));
boost::shared_ptr<peer_connection> p =
boost::make_shared<peer_connection>(manager, t1, 1, false, "no-priority");
v.push_back(p);
run_test(v, manager);
@ -440,8 +439,8 @@ void test_no_starvation(int limit)
spawn_connections(v1, manager, t1, num_peers, "p");
connections_t v;
std::copy(v1.begin(), v1.end(), std::back_inserter(v));
boost::shared_ptr<peer_connection> p(
new peer_connection(manager, t2, 1, false, "no-priority"));
boost::shared_ptr<peer_connection> p =
boost::make_shared<peer_connection>(manager, t2, 1, false, "no-priority");
v.push_back(p);
run_test(v, manager);
@ -517,5 +516,3 @@ TORRENT_TEST(no_starvation)
{
test_no_starvation(40000);
}

2
test/test_block_cache.cpp
View File

@ -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; \
boost::shared_ptr<piece_manager> pm(boost::make_shared<piece_manager>(st, boost::shared_ptr<int>(new int), &fs)); \
std::shared_ptr<piece_manager> pm = std::make_shared<piece_manager>(st, boost::shared_ptr<int>(new int), &fs); \
error_code ec; \
bc.set_settings(sett, ec); \
st->m_settings = &sett; \

3
test/test_storage.cpp
View File

@ -463,7 +463,7 @@ void test_check_files(std::string const& test_path
p.mode = storage_mode;
boost::shared_ptr<void> dummy;
boost::shared_ptr<piece_manager> pm = boost::make_shared<piece_manager>(new default_storage(p), dummy, &fs);
std::shared_ptr<piece_manager> pm = std::make_shared<piece_manager>(new default_storage(p), dummy, &fs);
std::mutex lock;
bool done = false;
@ -1377,4 +1377,3 @@ TORRENT_TEST(dont_move_intermingled_files)
TEST_CHECK(!exists(combine_path(test_path, combine_path("temp_storage"
, combine_path("_folder3", "alien_folder1")))));
}

4
test/test_upnp.cpp
View File

@ -161,8 +161,8 @@ void run_upnp_test(char const* root_filename, char const* router_model, char con
std::string user_agent = "test agent";
boost::shared_ptr<upnp> upnp_handler(new upnp(std::ref(ios)
, user_agent, &callback, &log_callback, false));
std::shared_ptr<upnp> upnp_handler = std::make_shared<upnp>(std::ref(ios)
, user_agent, &callback, &log_callback, false);
upnp_handler->start();
upnp_handler->discover_device();