premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

use override and final keywords (unconditionally) (#668) 

use override and final keywords instead of macros.
This commit is contained in:
Arvid Norberg 2016-04-30 11:05:54 -04:00
parent f856b6bbe3
commit 4e97bf556c
29 changed files with 591 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
bindings/python/src/alert.cpp
View File

@ -163,6 +163,107 @@ dict session_stats_values(session_stats_alert const& alert)
return d;
}
namespace boost
{
// some older compilers (like msvc-12.0) end up using
// boost::is_polymorphic inside boost.python applied
// to alert types. This is problematic, since it appears
// to be implemented by deriving from the type, which
// yields a compiler error since most alerts are final.
// this just short-cuts the query to say that all these
// types are indeed polymorphic, no need to derive from
// them.
#define POLY(x) template<> \
struct is_polymorphic<libtorrent:: x > : boost::mpl::true_ {};
POLY(torrent_alert)
POLY(tracker_alert)
POLY(torrent_added_alert)
POLY(torrent_removed_alert)
POLY(read_piece_alert)
POLY(peer_alert)
POLY(tracker_error_alert)
POLY(tracker_warning_alert)
POLY(tracker_reply_alert)
POLY(tracker_announce_alert)
POLY(hash_failed_alert)
POLY(peer_ban_alert)
POLY(peer_error_alert)
POLY(invalid_request_alert)
POLY(torrent_error_alert)
POLY(torrent_finished_alert)
POLY(piece_finished_alert)
POLY(block_finished_alert)
POLY(block_downloading_alert)
POLY(storage_moved_alert)
POLY(storage_moved_failed_alert)
POLY(torrent_deleted_alert)
POLY(torrent_paused_alert)
POLY(torrent_checked_alert)
POLY(url_seed_alert)
POLY(file_error_alert)
POLY(metadata_failed_alert)
POLY(metadata_received_alert)
POLY(listen_failed_alert)
POLY(listen_succeeded_alert)
POLY(portmap_error_alert)
POLY(portmap_alert)
POLY(fastresume_rejected_alert)
POLY(peer_blocked_alert)
POLY(scrape_reply_alert)
POLY(scrape_failed_alert)
POLY(udp_error_alert)
POLY(external_ip_alert)
POLY(save_resume_data_alert)
POLY(file_completed_alert)
POLY(file_renamed_alert)
POLY(file_rename_failed_alert)
POLY(torrent_resumed_alert)
POLY(state_changed_alert)
POLY(state_update_alert)
POLY(i2p_alert)
POLY(dht_reply_alert)
POLY(dht_announce_alert)
POLY(dht_get_peers_alert)
POLY(peer_unsnubbed_alert)
POLY(peer_snubbed_alert)
POLY(peer_connect_alert)
POLY(peer_disconnected_alert)
POLY(request_dropped_alert)
POLY(block_timeout_alert)
POLY(unwanted_block_alert)
POLY(torrent_delete_failed_alert)
POLY(save_resume_data_failed_alert)
POLY(performance_alert)
POLY(stats_alert)
POLY(anonymous_mode_alert)
POLY(incoming_connection_alert)
POLY(torrent_need_cert_alert)
POLY(add_torrent_alert)
POLY(dht_outgoing_get_peers_alert)
POLY(lsd_error_alert)
POLY(dht_stats_alert)
POLY(dht_immutable_item_alert)
POLY(dht_mutable_item_alert)
POLY(dht_put_alert)
POLY(session_stats_alert)
POLY(dht_get_peers_reply_alert)
#ifndef TORRENT_NO_DEPRECATE
POLY(torrent_update_alert)
#endif
#ifndef TORRENT_DISABLE_LOGGING
POLY(portmap_log_alert)
POLY(log_alert)
POLY(torrent_log_alert)
POLY(peer_log_alert)
POLY(picker_log_alert)
#endif // TORRENT_DISABLE_LOGGING
#undef POLY
}
void bind_alert()
{
using boost::noncopyable;

2
docs/gen_reference_doc.py
View File

@ -149,7 +149,6 @@ def is_visible(desc):
return True
def highlight_signature(s):
s = s.replace('TORRENT_OVERRIDE', 'override').replace('TORRENT_FINAL', 'final')
name = s.split('(', 1)
name2 = name[0].split(' ')
if len(name2[-1]) == 0: return s
@ -274,7 +273,6 @@ def parse_class(lno, lines, filename):
state = 'private'
class_type = 'class'
decl = decl.replace('TORRENT_FINAL', 'final')
name = decl.split(':')[0].replace('class ', '').replace('struct ', '').replace('final', '').strip()

354
include/libtorrent/alert_types.hpp
View File

File diff suppressed because it is too large Load Diff

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

@ -186,7 +186,7 @@ namespace libtorrent
// this is the link between the main thread and the
// thread started to run the main downloader loop
struct TORRENT_EXTRA_EXPORT session_impl TORRENT_FINAL
struct TORRENT_EXTRA_EXPORT session_impl final
: session_interface
, dht::dht_observer
, boost::noncopyable
@ -224,10 +224,10 @@ namespace libtorrent
void add_ses_extension(boost::shared_ptr<plugin> ext);
#endif
#if TORRENT_USE_ASSERTS
bool has_peer(peer_connection const* p) const TORRENT_OVERRIDE;
bool any_torrent_has_peer(peer_connection const* p) const TORRENT_OVERRIDE;
bool is_single_thread() const TORRENT_OVERRIDE { return single_threaded::is_single_thread(); }
bool is_posting_torrent_updates() const TORRENT_OVERRIDE { return m_posting_torrent_updates; }
bool has_peer(peer_connection const* p) const override;
bool any_torrent_has_peer(peer_connection const* p) const override;
bool is_single_thread() const override { return single_threaded::is_single_thread(); }
bool is_posting_torrent_updates() const override { return m_posting_torrent_updates; }
// this is set while the session is building the
// torrent status update message
bool m_posting_torrent_updates;
@ -235,15 +235,15 @@ namespace libtorrent
void reopen_listen_sockets();
torrent_peer_allocator_interface* get_peer_allocator() TORRENT_OVERRIDE
torrent_peer_allocator_interface* get_peer_allocator() override
{ return &m_peer_allocator; }
io_service& get_io_service() TORRENT_OVERRIDE { return m_io_service; }
resolver_interface& get_resolver() TORRENT_OVERRIDE { return m_host_resolver; }
io_service& get_io_service() override { return m_io_service; }
resolver_interface& get_resolver() override { return m_host_resolver; }
void async_resolve(std::string const& host, int flags
, callback_t const& h) TORRENT_OVERRIDE;
, callback_t const& h) override;
std::vector<torrent*>& torrent_list(int i) TORRENT_OVERRIDE
std::vector<torrent*>& torrent_list(int i) override
{
TORRENT_ASSERT(i >= 0);
TORRENT_ASSERT(i < session_interface::num_torrent_lists);
@ -254,10 +254,10 @@ 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<torrent> t) TORRENT_OVERRIDE;
void prioritize_connections(boost::weak_ptr<torrent> t) override;
tcp::endpoint get_ipv6_interface() const TORRENT_OVERRIDE;
tcp::endpoint get_ipv4_interface() const TORRENT_OVERRIDE;
tcp::endpoint get_ipv6_interface() const override;
tcp::endpoint get_ipv4_interface() const override;
void async_accept(boost::shared_ptr<tcp::acceptor> const& listener, bool ssl);
void on_accept_connection(boost::shared_ptr<socket_type> const& s
@ -267,49 +267,49 @@ namespace libtorrent
void incoming_connection(boost::shared_ptr<socket_type> const& s);
boost::weak_ptr<torrent> find_torrent(sha1_hash const& info_hash) const TORRENT_OVERRIDE;
boost::weak_ptr<torrent> find_torrent(sha1_hash const& info_hash) const override;
#ifndef TORRENT_NO_DEPRECATE
//deprecated in 1.2
boost::weak_ptr<torrent> find_torrent(std::string const& uuid) const;
#endif
#ifndef TORRENT_DISABLE_MUTABLE_TORRENTS
std::vector<boost::shared_ptr<torrent> > find_collection(
std::string const& collection) const TORRENT_OVERRIDE;
std::string const& collection) const override;
#endif
boost::weak_ptr<torrent> find_disconnect_candidate_torrent() const TORRENT_OVERRIDE;
int num_torrents() const TORRENT_OVERRIDE { return int(m_torrents.size()); }
boost::weak_ptr<torrent> 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<torrent> const& t
, std::string uuid) TORRENT_OVERRIDE;
, std::string uuid) override;
#ifndef TORRENT_NO_DEPRECATE
//deprecated in 1.2
void insert_uuid_torrent(std::string uuid, boost::shared_ptr<torrent> const& t) TORRENT_OVERRIDE
void insert_uuid_torrent(std::string uuid, boost::shared_ptr<torrent> const& t) override
{ m_uuids.insert(std::make_pair(uuid, t)); }
#endif
boost::shared_ptr<torrent> delay_load_torrent(sha1_hash const& info_hash
, peer_connection* pc) TORRENT_OVERRIDE;
void set_queue_position(torrent* t, int p) TORRENT_OVERRIDE;
, peer_connection* pc) override;
void set_queue_position(torrent* t, int p) override;
peer_id const& get_peer_id() const TORRENT_OVERRIDE { return m_peer_id; }
peer_id const& get_peer_id() const override { return m_peer_id; }
void close_connection(peer_connection* p, error_code const& ec) TORRENT_OVERRIDE;
void close_connection(peer_connection* p, error_code const& ec) override;
#ifndef TORRENT_NO_DEPRECATE
void set_settings(libtorrent::session_settings const& s);
libtorrent::session_settings deprecated_settings() const;
#endif
void apply_settings_pack(boost::shared_ptr<settings_pack> pack) TORRENT_OVERRIDE;
void apply_settings_pack(boost::shared_ptr<settings_pack> pack) override;
void apply_settings_pack_impl(settings_pack const& pack);
session_settings const& settings() const TORRENT_OVERRIDE { return m_settings; }
session_settings const& settings() const override { return m_settings; }
settings_pack get_settings() const;
#ifndef TORRENT_DISABLE_DHT
dht::dht_tracker* dht() TORRENT_OVERRIDE { return m_dht.get(); }
bool announce_dht() const TORRENT_OVERRIDE { return !m_listen_sockets.empty(); }
dht::dht_tracker* dht() override { return m_dht.get(); }
bool announce_dht() const override { return !m_listen_sockets.empty(); }
void add_dht_node_name(std::pair<std::string, int> const& node);
void add_dht_node(udp::endpoint n) TORRENT_OVERRIDE;
void add_dht_node(udp::endpoint n) override;
void add_dht_router(std::pair<std::string, int> const& node);
void set_dht_settings(dht_settings const& s);
dht_settings const& get_dht_settings() const { return m_dht_settings; }
@ -317,12 +317,12 @@ namespace libtorrent
void start_dht();
void stop_dht();
void start_dht(entry const& startup_state);
bool has_dht() const TORRENT_OVERRIDE;
bool has_dht() const override;
// 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<torrent> t) TORRENT_OVERRIDE;
void prioritize_dht(boost::weak_ptr<torrent> t) override;
void get_immutable_callback(sha1_hash target
, dht::item const& i);
@ -358,9 +358,9 @@ namespace libtorrent
#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
torrent const* find_encrypted_torrent(
sha1_hash const& info_hash, sha1_hash const& xor_mask) TORRENT_OVERRIDE;
sha1_hash const& info_hash, sha1_hash const& xor_mask) override;
void add_obfuscated_hash(sha1_hash const& obfuscated, boost::weak_ptr<torrent> const& t) TORRENT_OVERRIDE;
void add_obfuscated_hash(sha1_hash const& obfuscated, boost::weak_ptr<torrent> const& t) override;
#endif
void on_port_map_log(char const* msg, int map_transport);
@ -375,8 +375,8 @@ namespace libtorrent
void on_port_mapping(int mapping, address const& ip, int port
, int protocol, error_code const& ec, int nat_transport);
bool is_aborted() const TORRENT_OVERRIDE { return m_abort; }
bool is_paused() const TORRENT_OVERRIDE { return m_paused; }
bool is_aborted() const override { return m_abort; }
bool is_paused() const override { return m_paused; }
void pause();
void resume();
@ -385,22 +385,22 @@ namespace libtorrent
ip_filter const& get_ip_filter();
void set_port_filter(port_filter const& f);
port_filter const& get_port_filter() const TORRENT_OVERRIDE;
void ban_ip(address addr) TORRENT_OVERRIDE;
port_filter const& get_port_filter() const override;
void ban_ip(address addr) override;
void queue_tracker_request(tracker_request& req
, boost::weak_ptr<request_callback> c) TORRENT_OVERRIDE;
, boost::weak_ptr<request_callback> c) override;
// ==== peer class operations ====
// implements session_interface
void set_peer_classes(peer_class_set* s, address const& a, int st) TORRENT_OVERRIDE;
peer_class_pool const& peer_classes() const TORRENT_OVERRIDE { return m_classes; }
peer_class_pool& peer_classes() TORRENT_OVERRIDE { return m_classes; }
bool ignore_unchoke_slots_set(peer_class_set const& set) const TORRENT_OVERRIDE;
void set_peer_classes(peer_class_set* s, address const& a, int st) override;
peer_class_pool const& peer_classes() const override { return m_classes; }
peer_class_pool& peer_classes() override { return m_classes; }
bool ignore_unchoke_slots_set(peer_class_set const& set) const override;
int copy_pertinent_channels(peer_class_set const& set
, int channel, bandwidth_channel** dst, int max) TORRENT_OVERRIDE;
int use_quota_overhead(peer_class_set& set, int amount_down, int amount_up) TORRENT_OVERRIDE;
, int channel, bandwidth_channel** dst, int max) override;
int use_quota_overhead(peer_class_set& set, int amount_down, int amount_up) override;
bool use_quota_overhead(bandwidth_channel* ch, int amount);
int create_peer_class(char const* name);
@ -426,8 +426,8 @@ namespace libtorrent
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) TORRENT_OVERRIDE;
void remove_torrent_impl(boost::shared_ptr<torrent> tptr, int options) TORRENT_OVERRIDE;
void remove_torrent(torrent_handle const& h, int options) override;
void remove_torrent_impl(boost::shared_ptr<torrent> tptr, int options) override;
void get_torrent_status(std::vector<torrent_status>* ret
, boost::function<bool(torrent_status const&)> const& pred
@ -464,7 +464,7 @@ namespace libtorrent
int max_uploads() const;
#endif
bandwidth_manager* get_bandwidth_manager(int channel) TORRENT_OVERRIDE;
bandwidth_manager* get_bandwidth_manager(int channel) override;
int upload_rate_limit(peer_class_t c) const;
int download_rate_limit(peer_class_t c) const;
@ -474,19 +474,19 @@ namespace libtorrent
void set_rate_limit(peer_class_t c, int channel, int limit);
int rate_limit(peer_class_t c, int channel) const;
bool preemptive_unchoke() const TORRENT_OVERRIDE;
int num_uploads() const TORRENT_OVERRIDE
bool preemptive_unchoke() const override;
int num_uploads() const override
{ return int(m_stats_counters[counters::num_peers_up_unchoked]); }
int num_connections() const TORRENT_OVERRIDE { return int(m_connections.size()); }
int num_connections() const override { return int(m_connections.size()); }
int peak_up_rate() const { return m_peak_up_rate; }
void trigger_unchoke() TORRENT_OVERRIDE
void trigger_unchoke() override
{
TORRENT_ASSERT(is_single_thread());
m_unchoke_time_scaler = 0;
}
void trigger_optimistic_unchoke() TORRENT_OVERRIDE
void trigger_optimistic_unchoke() override
{
TORRENT_ASSERT(is_single_thread());
m_optimistic_unchoke_time_scaler = 0;
@ -499,30 +499,30 @@ namespace libtorrent
void set_peer_id(peer_id const& id);
void set_key(int key);
address listen_address() const;
boost::uint16_t listen_port() const TORRENT_OVERRIDE;
boost::uint16_t ssl_listen_port() const TORRENT_OVERRIDE;
boost::uint16_t listen_port() const override;
boost::uint16_t ssl_listen_port() const override;
alert_manager& alerts() TORRENT_OVERRIDE { return m_alerts; }
disk_interface& disk_thread() TORRENT_OVERRIDE { return m_disk_thread; }
alert_manager& alerts() override { return m_alerts; }
disk_interface& disk_thread() override { return m_disk_thread; }
void abort();
void abort_stage2();
torrent_handle find_torrent_handle(sha1_hash const& info_hash);
void announce_lsd(sha1_hash const& ih, int port, bool broadcast = false) TORRENT_OVERRIDE;
void announce_lsd(sha1_hash const& ih, int port, bool broadcast = false) override;
void save_state(entry* e, boost::uint32_t flags) const;
void load_state(bdecode_node const* e, boost::uint32_t flags);
bool has_connection(peer_connection* p) const TORRENT_OVERRIDE;
void insert_peer(boost::shared_ptr<peer_connection> const& c) TORRENT_OVERRIDE;
bool has_connection(peer_connection* p) const override;
void insert_peer(boost::shared_ptr<peer_connection> const& c) override;
proxy_settings proxy() const TORRENT_OVERRIDE;
proxy_settings proxy() const override;
#ifndef TORRENT_DISABLE_DHT
bool is_dht_running() const { return (m_dht.get() != NULL); }
int external_udp_port() const TORRENT_OVERRIDE
int external_udp_port() const override
{
for (std::list<listen_socket_t>::const_iterator i = m_listen_sockets.begin()
, end(m_listen_sockets.end()); i != end; ++i)
@ -534,8 +534,8 @@ namespace libtorrent
#endif
#if TORRENT_USE_I2P
char const* i2p_session() const TORRENT_OVERRIDE { return m_i2p_conn.session_id(); }
proxy_settings i2p_proxy() const TORRENT_OVERRIDE;
char const* i2p_session() const override { return m_i2p_conn.session_id(); }
proxy_settings i2p_proxy() const override;
void on_i2p_open(error_code const& ec);
void open_new_incoming_i2p_connection();
@ -562,57 +562,57 @@ namespace libtorrent
// t is the least recently used, then the next least recently
// used is picked
// returns true if the torrent was loaded successfully
bool load_torrent(torrent* t) TORRENT_OVERRIDE;
bool load_torrent(torrent* t) override;
// bump t to the top of the list of least recently used. i.e.
// make it the most recently used. This is done every time
// an action is performed that required the torrent to be
// loaded, indicating activity
void bump_torrent(torrent* t, bool back = true) TORRENT_OVERRIDE;
void bump_torrent(torrent* t, bool back = true) override;
// evict torrents until there's space for one new torrent,
void evict_torrents_except(torrent* ignore);
void evict_torrent(torrent* t) TORRENT_OVERRIDE;
void evict_torrent(torrent* t) override;
void deferred_submit_jobs() TORRENT_OVERRIDE;
void deferred_submit_jobs() override;
char* allocate_buffer() TORRENT_OVERRIDE;
char* allocate_buffer() override;
torrent_peer* allocate_peer_entry(int type);
void free_peer_entry(torrent_peer* p);
void free_buffer(char* buf) TORRENT_OVERRIDE;
int send_buffer_size() const TORRENT_OVERRIDE { return send_buffer_size_impl; }
void free_buffer(char* buf) override;
int send_buffer_size() const override { return send_buffer_size_impl; }
// implements buffer_allocator_interface
void free_disk_buffer(char* buf) TORRENT_OVERRIDE;
char* allocate_disk_buffer(char const* category) TORRENT_OVERRIDE;
void free_disk_buffer(char* buf) override;
char* allocate_disk_buffer(char const* category) override;
char* allocate_disk_buffer(bool& exceeded
, boost::shared_ptr<disk_observer> o
, char const* category) TORRENT_OVERRIDE;
void reclaim_block(block_cache_reference ref) TORRENT_OVERRIDE;
, char const* category) override;
void reclaim_block(block_cache_reference ref) override;
bool exceeded_cache_use() const
{ return m_disk_thread.exceeded_cache_use(); }
// implements dht_observer
virtual void set_external_address(address const& ip
, address const& source) TORRENT_OVERRIDE;
virtual address external_address(udp proto) TORRENT_OVERRIDE;
virtual void get_peers(sha1_hash const& ih) TORRENT_OVERRIDE;
virtual void announce(sha1_hash const& ih, address const& addr, int port) TORRENT_OVERRIDE;
, address const& source) override;
virtual address external_address(udp proto) override;
virtual void get_peers(sha1_hash const& ih) override;
virtual void announce(sha1_hash const& ih, address const& addr, int port) override;
virtual void outgoing_get_peers(sha1_hash const& target
, sha1_hash const& sent_target, udp::endpoint const& ep) TORRENT_OVERRIDE;
, sha1_hash const& sent_target, udp::endpoint const& ep) override;
virtual void log(libtorrent::dht::dht_logger::module_t m, char const* fmt, ...)
TORRENT_OVERRIDE TORRENT_FORMAT(3,4);
override TORRENT_FORMAT(3,4);
virtual void log_packet(message_direction_t dir, char const* pkt, int len
, udp::endpoint node) TORRENT_OVERRIDE;
, udp::endpoint node) override;
virtual bool on_dht_request(char const* query, int query_len
, dht::msg const& request, entry& response) TORRENT_OVERRIDE;
, dht::msg const& request, entry& response) override;
void set_external_address(address const& ip
, int source_type, address const& source) TORRENT_OVERRIDE;
virtual external_ip const& external_address() const TORRENT_OVERRIDE;
, int source_type, address const& source) override;
virtual external_ip const& external_address() const override;
// used when posting synchronous function
// calls to session_impl and torrent objects
@ -621,32 +621,32 @@ namespace libtorrent
// cork a peer and schedule a delayed uncork
// does nothing if the peer is already corked
void cork_burst(peer_connection* p) TORRENT_OVERRIDE;
void cork_burst(peer_connection* p) override;
// uncork all peers added to the delayed uncork queue
// implements uncork_interface
virtual void do_delayed_uncork() TORRENT_OVERRIDE;
virtual void do_delayed_uncork() override;
void post_socket_job(socket_job& j) TORRENT_OVERRIDE;
void post_socket_job(socket_job& j) override;
// implements session_interface
virtual tcp::endpoint bind_outgoing_socket(socket_type& s, address
const& remote_address, error_code& ec) const TORRENT_OVERRIDE;
const& remote_address, error_code& ec) const override;
virtual bool verify_bound_address(address const& addr, bool utp
, error_code& ec) TORRENT_OVERRIDE;
, error_code& ec) override;
bool has_lsd() const TORRENT_OVERRIDE { return m_lsd.get() != NULL; }
bool has_lsd() const override { return m_lsd.get() != NULL; }
std::vector<block_info>& block_info_storage() TORRENT_OVERRIDE { return m_block_info_storage; }
std::vector<block_info>& block_info_storage() override { return m_block_info_storage; }
libtorrent::utp_socket_manager* utp_socket_manager() TORRENT_OVERRIDE
libtorrent::utp_socket_manager* utp_socket_manager() override
{ return &m_utp_socket_manager; }
#ifdef TORRENT_USE_OPENSSL
libtorrent::utp_socket_manager* ssl_utp_socket_manager() TORRENT_OVERRIDE
libtorrent::utp_socket_manager* ssl_utp_socket_manager() override
{ return &m_ssl_utp_socket_manager; }
#endif
void inc_boost_connections() TORRENT_OVERRIDE { ++m_boost_connections; }
void inc_boost_connections() override { ++m_boost_connections; }
#ifndef TORRENT_NO_DEPRECATE
void update_ssl_listen();
@ -691,7 +691,7 @@ namespace libtorrent
void update_connections_limit();
void update_alert_mask();
void trigger_auto_manage() TORRENT_OVERRIDE;
void trigger_auto_manage() override;
private:
@ -710,7 +710,7 @@ namespace libtorrent
void on_trigger_auto_manage();
void on_lsd_peer(tcp::endpoint peer, sha1_hash const& ih);
void setup_socket_buffers(socket_type& s) TORRENT_OVERRIDE;
void setup_socket_buffers(socket_type& s) override;
// the settings for the client
aux::session_settings m_settings;
@ -954,11 +954,11 @@ namespace libtorrent
stat m_stat;
// implements session_interface
virtual void sent_bytes(int bytes_payload, int bytes_protocol) TORRENT_OVERRIDE;
virtual void received_bytes(int bytes_payload, int bytes_protocol) TORRENT_OVERRIDE;
virtual void trancieve_ip_packet(int bytes, bool ipv6) TORRENT_OVERRIDE;
virtual void sent_syn(bool ipv6) TORRENT_OVERRIDE;
virtual void received_synack(bool ipv6) TORRENT_OVERRIDE;
virtual void sent_bytes(int bytes_payload, int bytes_protocol) override;
virtual void received_bytes(int bytes_payload, int bytes_protocol) override;
virtual void trancieve_ip_packet(int bytes, bool ipv6) override;
virtual void sent_syn(bool ipv6) override;
virtual void received_synack(bool ipv6) override;
int m_peak_up_rate;
int m_peak_down_rate;
@ -976,7 +976,7 @@ namespace libtorrent
void recalculate_optimistic_unchoke_slots();
time_point m_created;
boost::uint16_t session_time() const TORRENT_OVERRIDE
boost::uint16_t session_time() const override
{
// +1 is here to make it possible to distinguish uninitialized (to
// 0) timestamps and timestamps of things that happened during the
@ -1054,7 +1054,6 @@ namespace libtorrent
#ifdef TORRENT_USE_OPENSSL
// used for uTP connections over SSL
udp_socket m_ssl_udp_socket;
libtorrent::utp_socket_manager m_ssl_utp_socket_manager;
#endif
@ -1146,10 +1145,10 @@ namespace libtorrent
void check_invariant() const;
#endif
counters& stats_counters() TORRENT_OVERRIDE { return m_stats_counters; }
counters& stats_counters() override { return m_stats_counters; }
void received_buffer(int size) TORRENT_OVERRIDE;
void sent_buffer(int size) TORRENT_OVERRIDE;
void received_buffer(int size) override;
void sent_buffer(int size) override;
// each second tick the timer takes a little
// bit longer than one second to trigger. The
@ -1162,8 +1161,8 @@ namespace libtorrent
boost::uint16_t m_tick_residual;
#ifndef TORRENT_DISABLE_LOGGING
virtual void session_log(char const* fmt, ...) const TORRENT_OVERRIDE TORRENT_FORMAT(2,3);
virtual void session_vlog(char const* fmt, va_list& va) const TORRENT_OVERRIDE TORRENT_FORMAT(2,0);
virtual void session_log(char const* fmt, ...) const override TORRENT_FORMAT(2,3);
virtual void session_vlog(char const* fmt, va_list& va) const override TORRENT_FORMAT(2,0);
// this list of tracker loggers serves as tracker_callbacks when
// shutting down. This list is just here to keep them alive during

2
include/libtorrent/bencode.hpp
View File

@ -98,7 +98,7 @@ namespace libtorrent
{
// hidden
virtual const char* what() const TORRENT_EXCEPTION_THROW_SPECIFIER
TORRENT_OVERRIDE TORRENT_FINAL
override final
{ return "invalid bencoding"; }
};
#endif

50
include/libtorrent/bt_peer_connection.hpp
View File

@ -79,7 +79,7 @@ namespace libtorrent
bt_peer_connection(peer_connection_args const& pack
, peer_id const& pid);
virtual void start() TORRENT_OVERRIDE;
virtual void start() override;
enum
{
@ -105,7 +105,7 @@ namespace libtorrent
void switch_recv_crypto(boost::shared_ptr<crypto_plugin> crypto);
#endif
virtual int type() const TORRENT_OVERRIDE
virtual int type() const override
{ return peer_connection::bittorrent_connection; }
enum message_type
@ -153,17 +153,17 @@ namespace libtorrent
// work to do.
void on_sent(error_code const& error
, std::size_t bytes_transferred) TORRENT_OVERRIDE;
, std::size_t bytes_transferred) override;
void on_receive(error_code const& error
, std::size_t bytes_transferred) TORRENT_OVERRIDE;
, std::size_t bytes_transferred) override;
void on_receive_impl(std::size_t bytes_transferred);
#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
virtual int hit_send_barrier(std::vector<boost::asio::mutable_buffer>& iovec) TORRENT_OVERRIDE;
virtual int hit_send_barrier(std::vector<boost::asio::mutable_buffer>& iovec) override;
#endif
virtual void get_specific_peer_info(peer_info& p) const TORRENT_OVERRIDE;
virtual bool in_handshake() const TORRENT_OVERRIDE;
virtual void get_specific_peer_info(peer_info& p) const override;
virtual bool in_handshake() const override;
bool packet_finished() const { return m_recv_buffer.packet_finished(); }
#ifndef TORRENT_DISABLE_EXTENSIONS
@ -212,17 +212,17 @@ namespace libtorrent
// the following functions appends messages
// to the send buffer
void write_choke() TORRENT_OVERRIDE;
void write_unchoke() TORRENT_OVERRIDE;
void write_interested() TORRENT_OVERRIDE;
void write_not_interested() TORRENT_OVERRIDE;
void write_request(peer_request const& r) TORRENT_OVERRIDE;
void write_cancel(peer_request const& r) TORRENT_OVERRIDE;
void write_bitfield() TORRENT_OVERRIDE;
void write_have(int index) TORRENT_OVERRIDE;
void write_dont_have(int index) TORRENT_OVERRIDE;
void write_piece(peer_request const& r, disk_buffer_holder& buffer) TORRENT_OVERRIDE;
void write_keepalive() TORRENT_OVERRIDE;
void write_choke() override;
void write_unchoke() override;
void write_interested() override;
void write_not_interested() override;
void write_request(peer_request const& r) override;
void write_cancel(peer_request const& r) override;
void write_bitfield() override;
void write_have(int index) override;
void write_dont_have(int index) override;
void write_piece(peer_request const& r, disk_buffer_holder& buffer) override;
void write_keepalive() override;
void write_handshake(bool plain_handshake = false);
#ifndef TORRENT_DISABLE_EXTENSIONS
void write_extensions();
@ -239,12 +239,12 @@ namespace libtorrent
// FAST extension
void write_have_all();
void write_have_none();
void write_reject_request(peer_request const&) TORRENT_OVERRIDE;
void write_allow_fast(int piece) TORRENT_OVERRIDE;
void write_suggest(int piece) TORRENT_OVERRIDE;
void write_reject_request(peer_request const&) override;
void write_allow_fast(int piece) override;
void write_suggest(int piece) override;
void on_connected() TORRENT_OVERRIDE;
void on_metadata() TORRENT_OVERRIDE;
void on_connected() override;
void on_metadata() override;
#if TORRENT_USE_INVARIANT_CHECKS
void check_invariant() const;
@ -259,7 +259,7 @@ namespace libtorrent
// block. If the peer isn't downloading
// a piece for the moment, the boost::optional
// will be invalid.
boost::optional<piece_block_progress> downloading_piece_progress() const TORRENT_OVERRIDE;
boost::optional<piece_block_progress> downloading_piece_progress() const override;
#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
@ -301,7 +301,7 @@ public:
virtual void append_const_send_buffer(char const* buffer, int size
, chained_buffer::free_buffer_fun destructor = &nop
, void* userdata = NULL, block_cache_reference ref
= block_cache_reference()) TORRENT_OVERRIDE;
= block_cache_reference()) override;
private:

12
include/libtorrent/config.hpp
View File

@ -438,18 +438,6 @@ int snprintf(char* buf, int len, char const* fmt, ...)
#endif
#endif // __GLIBC__
#if __cplusplus <= 199711L || defined BOOST_NO_CXX11_FINAL
#define TORRENT_FINAL
#else
#define TORRENT_FINAL final
#endif
#if __cplusplus <= 199711L || defined BOOST_NO_CXX11_FINAL
#define TORRENT_OVERRIDE
#else
#define TORRENT_OVERRIDE override
#endif
#ifndef TORRENT_ICONV_ARG
#define TORRENT_ICONV_ARG (char**)
#endif

54
include/libtorrent/disk_io_thread.hpp
View File

@ -281,7 +281,7 @@ namespace libtorrent
// this is a singleton consisting of the thread and a queue
// of disk io jobs
struct TORRENT_EXTRA_EXPORT disk_io_thread TORRENT_FINAL
struct TORRENT_EXTRA_EXPORT disk_io_thread final
: disk_job_pool
, disk_interface
, buffer_allocator_interface
@ -299,60 +299,60 @@ namespace libtorrent
void async_read(piece_manager* storage, peer_request const& r
, boost::function<void(disk_io_job const*)> const& handler, void* requester
, int flags = 0) TORRENT_OVERRIDE;
, int flags = 0) override;
void async_write(piece_manager* storage, peer_request const& r
, disk_buffer_holder& buffer
, boost::function<void(disk_io_job const*)> const& handler
, int flags = 0) TORRENT_OVERRIDE;
, int flags = 0) override;
void async_hash(piece_manager* storage, int piece, int flags
, boost::function<void(disk_io_job const*)> const& handler, void* requester) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler, void* requester) override;
void async_move_storage(piece_manager* storage, std::string const& p, int flags
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_release_files(piece_manager* storage
, boost::function<void(disk_io_job const*)> const& handler
= boost::function<void(disk_io_job const*)>()) TORRENT_OVERRIDE;
= boost::function<void(disk_io_job const*)>()) override;
void async_delete_files(piece_manager* storage, int options
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_check_files(piece_manager* storage
, add_torrent_params const* resume_data
, std::vector<std::string>& links
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_rename_file(piece_manager* storage, int index, std::string const& name
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_stop_torrent(piece_manager* storage
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
#ifndef TORRENT_NO_DEPRECATE
void async_cache_piece(piece_manager* storage, int piece
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_finalize_file(piece_manager* storage, int file
, boost::function<void(disk_io_job const*)> const& handler
= boost::function<void(disk_io_job const*)>()) TORRENT_OVERRIDE;
= boost::function<void(disk_io_job const*)>()) override;
#endif
void async_flush_piece(piece_manager* storage, int piece
, boost::function<void(disk_io_job const*)> const& handler
= boost::function<void(disk_io_job const*)>()) TORRENT_OVERRIDE;
= boost::function<void(disk_io_job const*)>()) override;
void async_set_file_priority(piece_manager* storage
, std::vector<boost::uint8_t> const& prio
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_load_torrent(add_torrent_params* params
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void async_tick_torrent(piece_manager* storage
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
void clear_read_cache(piece_manager* storage) TORRENT_OVERRIDE;
void clear_read_cache(piece_manager* storage) override;
void async_clear_piece(piece_manager* storage, int index
, boost::function<void(disk_io_job const*)> const& handler) TORRENT_OVERRIDE;
, boost::function<void(disk_io_job const*)> const& handler) override;
// this is not asynchronous and requires that the piece does not
// have any pending buffers. It's meant to be used for pieces that
// were just read and hashed and failed the hash check.
// there should be no read-operations left, and all buffers should
// be discardable
void clear_piece(piece_manager* storage, int index) TORRENT_OVERRIDE;
void clear_piece(piece_manager* storage, int index) override;
// implements buffer_allocator_interface
void reclaim_block(block_cache_reference ref) TORRENT_OVERRIDE;
void free_disk_buffer(char* buf) TORRENT_OVERRIDE { m_disk_cache.free_buffer(buf); }
char* allocate_disk_buffer(char const* category) TORRENT_OVERRIDE
void reclaim_block(block_cache_reference ref) override;
void free_disk_buffer(char* buf) override { m_disk_cache.free_buffer(buf); }
char* allocate_disk_buffer(char const* category) override
{
bool exceed = false;
return allocate_disk_buffer(exceed, boost::shared_ptr<disk_observer>(), category);
@ -360,14 +360,14 @@ namespace libtorrent
void trigger_cache_trim();
char* allocate_disk_buffer(bool& exceeded, boost::shared_ptr<disk_observer> o
, char const* category) TORRENT_OVERRIDE;
, char const* category) override;
bool exceeded_cache_use() const
{ return m_disk_cache.exceeded_max_size(); }
void update_stats_counters(counters& c) const TORRENT_OVERRIDE;
void update_stats_counters(counters& c) const override;
void get_cache_info(cache_status* ret, bool no_pieces = true
, piece_manager const* storage = 0) const TORRENT_OVERRIDE;
, piece_manager const* storage = 0) const override;
// this submits all queued up jobs to the thread
void submit_jobs();
@ -375,7 +375,7 @@ namespace libtorrent
block_cache* cache() { return &m_disk_cache; }
#if TORRENT_USE_ASSERTS
bool is_disk_buffer(char* buffer) const TORRENT_OVERRIDE
bool is_disk_buffer(char* buffer) const override
{ return m_disk_cache.is_disk_buffer(buffer); }
#endif
@ -387,7 +387,7 @@ namespace libtorrent
void thread_fun(int thread_id, thread_type_t type
, boost::shared_ptr<io_service::work> w);
virtual file_pool& files() TORRENT_OVERRIDE { return m_file_pool; }
virtual file_pool& files() override { return m_file_pool; }
io_service& get_io_service() { return m_ios; }

14
include/libtorrent/http_seed_connection.hpp
View File

@ -80,20 +80,20 @@ namespace libtorrent
http_seed_connection(peer_connection_args const& pack
, web_seed_t& web);
virtual int type() const TORRENT_OVERRIDE
virtual int type() const override
{ return peer_connection::http_seed_connection; }
// called from the main loop when this connection has any
// work to do.
virtual void on_receive(error_code const& error
, std::size_t bytes_transferred) TORRENT_OVERRIDE;
, std::size_t bytes_transferred) override;
std::string const& url() const TORRENT_OVERRIDE { return m_url; }
std::string const& url() const override { return m_url; }
virtual void get_specific_peer_info(peer_info& p) const TORRENT_OVERRIDE;
virtual void disconnect(error_code const& ec, operation_t op, int error = 0) TORRENT_OVERRIDE;
virtual void get_specific_peer_info(peer_info& p) const override;
virtual void disconnect(error_code const& ec, operation_t op, int error = 0) override;
virtual void write_request(peer_request const& r) TORRENT_OVERRIDE;
virtual void write_request(peer_request const& r) override;
private:
@ -102,7 +102,7 @@ namespace libtorrent
// block. If the peer isn't downloading
// a piece for the moment, the boost::optional
// will be invalid.
boost::optional<piece_block_progress> downloading_piece_progress() const TORRENT_OVERRIDE;
boost::optional<piece_block_progress> downloading_piece_progress() const override;
// this is const since it's used as a key in the web seed list in the torrent
// if it's changed referencing back into that list will fail

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

@ -67,7 +67,7 @@ namespace libtorrent { namespace dht
{
struct dht_tracker;
struct TORRENT_EXTRA_EXPORT dht_tracker TORRENT_FINAL
struct TORRENT_EXTRA_EXPORT dht_tracker final
: udp_socket_interface
, boost::enable_shared_from_this<dht_tracker>
{
@ -147,8 +147,8 @@ namespace libtorrent { namespace dht
void refresh_key(error_code const& e);
// implements udp_socket_interface
virtual bool has_quota() TORRENT_OVERRIDE;
virtual bool send_packet(libtorrent::entry& e, udp::endpoint const& addr) TORRENT_OVERRIDE;
virtual bool has_quota() override;
virtual bool send_packet(libtorrent::entry& e, udp::endpoint const& addr) override;
// this is the bdecode_node DHT messages are parsed into. It's a member
// in order to avoid having to deallocate and re-allocate it for every

8
include/libtorrent/kademlia/put_data.hpp
View File

@ -57,8 +57,8 @@ struct put_data: traversal_algorithm
put_data(node& node, put_callback const& callback);
virtual char const* name() const TORRENT_OVERRIDE;
virtual void start() TORRENT_OVERRIDE;
virtual char const* name() const override;
virtual void start() override;
void set_data(item const& data) { m_data = data; }
@ -66,8 +66,8 @@ struct put_data: traversal_algorithm
protected:
virtual void done() TORRENT_OVERRIDE;
virtual bool invoke(observer_ptr o) TORRENT_OVERRIDE;
virtual void done() override;
virtual bool invoke(observer_ptr o) override;
put_callback m_put_callback;
item m_data;

8
include/libtorrent/pe_crypto.hpp
View File

@ -128,14 +128,14 @@ namespace libtorrent
rc4_handler();
// Input keys must be 20 bytes
void set_incoming_key(unsigned char const* key, int len) TORRENT_OVERRIDE;
void set_outgoing_key(unsigned char const* key, int len) TORRENT_OVERRIDE;
void set_incoming_key(unsigned char const* key, int len) override;
void set_outgoing_key(unsigned char const* key, int len) override;
int encrypt(std::vector<boost::asio::mutable_buffer>& buf) TORRENT_OVERRIDE;
int encrypt(std::vector<boost::asio::mutable_buffer>& buf) override;
void decrypt(std::vector<boost::asio::mutable_buffer>& buf
, int& consume
, int& produce
, int& packet_size) TORRENT_OVERRIDE;
, int& packet_size) override;
private:
rc4 m_rc4_incoming;

6
include/libtorrent/resolver.hpp
View File

@ -52,14 +52,14 @@ POSSIBILITY OF SUCH DAMAGE.
namespace libtorrent
{
struct TORRENT_EXTRA_EXPORT resolver TORRENT_FINAL : resolver_interface
struct TORRENT_EXTRA_EXPORT resolver final : resolver_interface
{
resolver(io_service& ios);
virtual void async_resolve(std::string const& host, int flags
, callback_t const& h) TORRENT_OVERRIDE;
, callback_t const& h) override;
virtual void abort() TORRENT_OVERRIDE;
virtual void abort() override;
private:

68
include/libtorrent/storage.hpp
View File

@ -399,27 +399,27 @@ namespace libtorrent
~default_storage();
#ifndef TORRENT_NO_DEPRECATE
void finalize_file(int file, storage_error& ec) TORRENT_OVERRIDE;
void finalize_file(int file, storage_error& ec) override;
#endif
virtual bool has_any_file(storage_error& ec) TORRENT_OVERRIDE;
virtual bool has_any_file(storage_error& ec) override;
virtual void set_file_priority(std::vector<boost::uint8_t> const& prio
, storage_error& ec) TORRENT_OVERRIDE;
, storage_error& ec) override;
virtual void rename_file(int index, std::string const& new_filename
, storage_error& ec) TORRENT_OVERRIDE;
virtual void release_files(storage_error& ec) TORRENT_OVERRIDE;
virtual void delete_files(int options, storage_error& ec) TORRENT_OVERRIDE;
virtual void initialize(storage_error& ec) TORRENT_OVERRIDE;
, storage_error& ec) override;
virtual void release_files(storage_error& ec) override;
virtual void delete_files(int options, storage_error& ec) override;
virtual void initialize(storage_error& ec) override;
virtual int move_storage(std::string const& save_path, int flags
, storage_error& ec) TORRENT_OVERRIDE;
, storage_error& ec) override;
virtual bool verify_resume_data(add_torrent_params const& rd
, std::vector<std::string> const* links
, storage_error& error) TORRENT_OVERRIDE;
virtual bool tick() TORRENT_OVERRIDE;
, storage_error& error) override;
virtual bool tick() override;
int readv(file::iovec_t const* bufs, int num_bufs
, int piece, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE;
, int piece, int offset, int flags, storage_error& ec) override;
int writev(file::iovec_t const* bufs, int num_bufs
, int piece, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE;
, int piece, int offset, int flags, storage_error& ec) override;
// if the files in this storage are mapped, returns the mapped
// file_storage, otherwise returns the original file_storage object.
@ -478,52 +478,52 @@ namespace libtorrent
// of normal bittorrent operation, since it will just send garbage
// to peers and throw away all the data it downloads. It would end
// up being banned immediately
class disabled_storage TORRENT_FINAL : public storage_interface, boost::noncopyable
class disabled_storage final : public storage_interface, boost::noncopyable
{
public:
virtual bool has_any_file(storage_error&) TORRENT_OVERRIDE { return false; }
virtual bool has_any_file(storage_error&) override { return false; }
virtual void set_file_priority(std::vector<boost::uint8_t> const&
, storage_error&) TORRENT_OVERRIDE {}
virtual void rename_file(int, std::string const&, storage_error&) TORRENT_OVERRIDE {}
virtual void release_files(storage_error&) TORRENT_OVERRIDE {}
virtual void delete_files(int, storage_error&) TORRENT_OVERRIDE {}
virtual void initialize(storage_error&) TORRENT_OVERRIDE {}
virtual int move_storage(std::string const&, int, storage_error&) TORRENT_OVERRIDE { return 0; }
, storage_error&) override {}
virtual void rename_file(int, std::string const&, storage_error&) override {}
virtual void release_files(storage_error&) override {}
virtual void delete_files(int, storage_error&) override {}
virtual void initialize(storage_error&) override {}
virtual int move_storage(std::string const&, int, storage_error&) override { return 0; }
virtual int readv(file::iovec_t const* bufs, int num_bufs, int piece
, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE;
, int offset, int flags, storage_error& ec) override;
virtual int writev(file::iovec_t const* bufs, int num_bufs, int piece
, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE;
, int offset, int flags, storage_error& ec) override;
virtual bool verify_resume_data(add_torrent_params const&
, std::vector<std::string> const*
, storage_error&) TORRENT_OVERRIDE { return false; }
, storage_error&) override { return false; }
};
// this storage implementation always reads zeroes, and always discards
// anything written to it
struct zero_storage TORRENT_FINAL : storage_interface
struct zero_storage final : storage_interface
{
virtual void initialize(storage_error&) TORRENT_OVERRIDE {}
virtual void initialize(storage_error&) override {}
virtual int readv(file::iovec_t const* bufs, int num_bufs
, int piece, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE;
, int piece, int offset, int flags, storage_error& ec) override;
virtual int writev(file::iovec_t const* bufs, int num_bufs
, int piece, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE;
, int piece, int offset, int flags, storage_error& ec) override;
virtual bool has_any_file(storage_error&) TORRENT_OVERRIDE { return false; }
virtual bool has_any_file(storage_error&) override { return false; }
virtual void set_file_priority(std::vector<boost::uint8_t> const& /* prio */
, storage_error&) TORRENT_OVERRIDE {}
, storage_error&) override {}
virtual int move_storage(std::string const& /* save_path */
, int /* flags */, storage_error&) TORRENT_OVERRIDE { return 0; }
, int /* flags */, storage_error&) override { return 0; }
virtual bool verify_resume_data(add_torrent_params const& /* rd */
, std::vector<std::string> const* /* links */
, storage_error&) TORRENT_OVERRIDE
, storage_error&) override
{ return false; }
virtual void release_files(storage_error&) TORRENT_OVERRIDE {}
virtual void release_files(storage_error&) override {}
virtual void rename_file(int /* index */
, std::string const& /* new_filenamem */, storage_error&) TORRENT_OVERRIDE {}
virtual void delete_files(int, storage_error&) TORRENT_OVERRIDE {}
, std::string const& /* new_filenamem */, storage_error&) override {}
virtual void delete_files(int, storage_error&) override {}
};
struct disk_io_thread;

10
include/libtorrent/torrent.hpp
View File

@ -673,14 +673,14 @@ namespace libtorrent
tracker_request const& r
, address const& tracker_ip
, std::list<address> const& ip_list
, struct tracker_response const& resp) TORRENT_OVERRIDE;
, struct tracker_response const& resp) override;
virtual void tracker_request_error(tracker_request const& r
, int response_code, error_code const& ec, const std::string& msg
, int retry_interval) TORRENT_OVERRIDE;
, int retry_interval) override;
virtual void tracker_warning(tracker_request const& req
, std::string const& msg) TORRENT_OVERRIDE;
, std::string const& msg) override;
virtual void tracker_scrape_response(tracker_request const& req
, int complete, int incomplete, int downloaded, int downloaders) TORRENT_OVERRIDE;
, int complete, int incomplete, int downloaded, int downloaders) override;
void update_scrape_state();
@ -983,7 +983,7 @@ namespace libtorrent
// LOGGING
#ifndef TORRENT_DISABLE_LOGGING
virtual void debug_log(const char* fmt, ...) const TORRENT_OVERRIDE TORRENT_FORMAT(2,3);
virtual void debug_log(const char* fmt, ...) const override TORRENT_FORMAT(2,3);
void log_to_all_peers(char const* message);
time_point m_dht_start_time;

2
include/libtorrent/torrent_peer_allocator.hpp
View File

@ -60,7 +60,7 @@ namespace libtorrent
~torrent_peer_allocator_interface() {}
};
struct TORRENT_EXTRA_EXPORT torrent_peer_allocator TORRENT_FINAL
struct TORRENT_EXTRA_EXPORT torrent_peer_allocator final
: torrent_peer_allocator_interface
{
torrent_peer_allocator();

2
include/libtorrent/tracker_manager.hpp
View File

@ -336,7 +336,7 @@ namespace libtorrent
tracker_manager& m_man;
};
class TORRENT_EXTRA_EXPORT tracker_manager TORRENT_FINAL
class TORRENT_EXTRA_EXPORT tracker_manager final
: boost::noncopyable
{
public:

2
include/libtorrent/utp_socket_manager.hpp
View File

@ -53,7 +53,7 @@ namespace libtorrent
struct utp_socket_impl;
struct counters;
struct utp_socket_manager TORRENT_FINAL
struct utp_socket_manager final
{
typedef boost::function<void(udp::endpoint const&
, aux::array_view<char const>

18
include/libtorrent/web_peer_connection.hpp
View File

@ -74,25 +74,25 @@ namespace libtorrent
web_peer_connection(peer_connection_args const& pack
, web_seed_t& web);
virtual void on_connected() TORRENT_OVERRIDE;
virtual void on_connected() override;
virtual int type() const TORRENT_OVERRIDE
virtual int type() const override
{ return peer_connection::url_seed_connection; }
// called from the main loop when this connection has any
// work to do.
virtual void on_receive(error_code const& error
, std::size_t bytes_transferred) TORRENT_OVERRIDE;
, std::size_t bytes_transferred) override;
std::string const& url() const TORRENT_OVERRIDE { return m_url; }
std::string const& url() const override { return m_url; }
virtual void get_specific_peer_info(peer_info& p) const TORRENT_OVERRIDE;
virtual void get_specific_peer_info(peer_info& p) const override;
virtual void disconnect(error_code const& ec
, operation_t op, int error = 0) TORRENT_OVERRIDE;
, operation_t op, int error = 0) override;
virtual void write_request(peer_request const& r) TORRENT_OVERRIDE;
virtual void write_request(peer_request const& r) override;
virtual bool received_invalid_data(int index, bool single_peer) TORRENT_OVERRIDE;
virtual bool received_invalid_data(int index, bool single_peer) override;
private:
@ -108,7 +108,7 @@ namespace libtorrent
// block. If the peer isn't downloading
// a piece for the moment, the boost::optional
// will be invalid.
boost::optional<piece_block_progress> downloading_piece_progress() const TORRENT_OVERRIDE;
boost::optional<piece_block_progress> downloading_piece_progress() const override;
void handle_padfile();

16
simulation/test_dht_rate_limit.cpp
View File

@ -54,20 +54,20 @@ using namespace sim;
struct obs : dht::dht_observer
{
virtual void set_external_address(address const& addr
, address const& source) TORRENT_OVERRIDE
, address const& source) override
{}
virtual address external_address(udp proto) TORRENT_OVERRIDE
virtual address external_address(udp proto) override
{
if (proto == udp::v4())
return address_v4::from_string("40.30.20.10");
else
return address_v6();
}
virtual void get_peers(sha1_hash const& ih) TORRENT_OVERRIDE {}
virtual void get_peers(sha1_hash const& ih) override {}
virtual void outgoing_get_peers(sha1_hash const& target
, sha1_hash const& sent_target, udp::endpoint const& ep) TORRENT_OVERRIDE {}
virtual void announce(sha1_hash const& ih, address const& addr, int port) TORRENT_OVERRIDE {}
virtual void log(dht_logger::module_t l, char const* fmt, ...) TORRENT_OVERRIDE
, sha1_hash const& sent_target, udp::endpoint const& ep) override {}
virtual void announce(sha1_hash const& ih, address const& addr, int port) override {}
virtual void log(dht_logger::module_t l, char const* fmt, ...) override
{
va_list v;
va_start(v, fmt);
@ -76,9 +76,9 @@ struct obs : dht::dht_observer
puts("\n");
}
virtual void log_packet(message_direction_t dir, char const* pkt, int len
, udp::endpoint node) TORRENT_OVERRIDE {}
, udp::endpoint node) override {}
virtual bool on_dht_request(char const* query, int query_len
, dht::msg const& request, entry& response) TORRENT_OVERRIDE { return false; }
, dht::msg const& request, entry& response) override { return false; }
};
#endif // #if !defined TORRENT_DISABLE_DHT

24
src/kademlia/dht_storage.cpp
View File

@ -183,7 +183,7 @@ namespace
node_id const& m_our_id;
};
class dht_default_storage TORRENT_FINAL : public dht_storage_interface, boost::noncopyable
class dht_default_storage final : public dht_storage_interface, boost::noncopyable
{
typedef std::map<node_id, torrent_entry> table_t;
typedef std::map<node_id, dht_immutable_item> dht_immutable_table_t;
@ -201,8 +201,8 @@ namespace
~dht_default_storage() {}
#ifndef TORRENT_NO_DEPRECATE
size_t num_torrents() const TORRENT_OVERRIDE { return m_map.size(); }
size_t num_peers() const TORRENT_OVERRIDE
size_t num_torrents() const override { return m_map.size(); }
size_t num_peers() const override
{
int ret = 0;
std::for_each(m_map.begin(), m_map.end(), count_peers(&ret));
@ -212,7 +212,7 @@ namespace
bool get_peers(sha1_hash const& info_hash
, bool noseed, bool scrape
, entry& peers) const TORRENT_OVERRIDE
, entry& peers) const override
{
table_t::const_iterator i = m_map.lower_bound(info_hash);
if (i == m_map.end()) return false;
@ -270,7 +270,7 @@ namespace
void announce_peer(sha1_hash const& info_hash
, tcp::endpoint const& endp
, std::string const& name, bool seed) TORRENT_OVERRIDE
, std::string const& name, bool seed) override
{
table_t::iterator ti = m_map.find(info_hash);
torrent_entry* v;
@ -338,7 +338,7 @@ namespace
}
bool get_immutable_item(sha1_hash const& target
, entry& item) const TORRENT_OVERRIDE
, entry& item) const override
{
dht_immutable_table_t::const_iterator i = m_immutable_table.find(target);
if (i == m_immutable_table.end()) return false;
@ -349,7 +349,7 @@ namespace
void put_immutable_item(sha1_hash const& target
, char const* buf, int size
, address const& addr) TORRENT_OVERRIDE
, address const& addr) override
{
dht_immutable_table_t::iterator i = m_immutable_table.find(target);
if (i == m_immutable_table.end())
@ -385,7 +385,7 @@ namespace
}
bool get_mutable_item_seq(sha1_hash const& target
, boost::int64_t& seq) const TORRENT_OVERRIDE
, boost::int64_t& seq) const override
{
dht_mutable_table_t::const_iterator i = m_mutable_table.find(target);
if (i == m_mutable_table.end()) return false;
@ -396,7 +396,7 @@ namespace
bool get_mutable_item(sha1_hash const& target
, boost::int64_t seq, bool force_fill
, entry& item) const TORRENT_OVERRIDE
, entry& item) const override
{
dht_mutable_table_t::const_iterator i = m_mutable_table.find(target);
if (i == m_mutable_table.end()) return false;
@ -418,7 +418,7 @@ namespace
, boost::int64_t seq
, char const* pk
, char const* salt, int salt_size
, address const& addr) TORRENT_OVERRIDE
, address const& addr) override
{
dht_mutable_table_t::iterator i = m_mutable_table.find(target);
if (i == m_mutable_table.end())
@ -486,7 +486,7 @@ namespace
touch_item(&i->second, addr);
}
void tick() TORRENT_OVERRIDE
void tick() override
{
time_point now(aux::time_now());
@ -541,7 +541,7 @@ namespace
}
}
virtual dht_storage_counters counters() const TORRENT_OVERRIDE
virtual dht_storage_counters counters() const override
{
return m_counters;
}

24
src/metadata_transfer.cpp
View File

@ -97,7 +97,7 @@ namespace libtorrent { namespace
return ret;
}
struct metadata_plugin TORRENT_FINAL
struct metadata_plugin final
: torrent_plugin
{
metadata_plugin(torrent& t)
@ -112,19 +112,19 @@ namespace libtorrent { namespace
bool need_loaded()
{ return m_torrent.need_loaded(); }
*/
virtual void on_unload() TORRENT_OVERRIDE
virtual void on_unload() override
{
m_metadata.reset();
}
virtual void on_load() TORRENT_OVERRIDE
virtual void on_load() override
{
// initialize m_metadata_size
TORRENT_ASSERT(m_torrent.is_loaded());
metadata();
}
virtual void on_files_checked() TORRENT_OVERRIDE
virtual void on_files_checked() override
{
// if the torrent is a seed, make a reference to
// the metadata from the torrent before it is deallocated
@ -132,7 +132,7 @@ namespace libtorrent { namespace
}
virtual boost::shared_ptr<peer_plugin> new_connection(
peer_connection_handle const& pc) TORRENT_OVERRIDE;
peer_connection_handle const& pc) override;
buffer::const_interval metadata() const
{
@ -219,7 +219,7 @@ namespace libtorrent { namespace
m_torrent.set_progress_ppm(boost::int64_t(m_metadata_progress) * 1000000 / m_metadata_size);
}
void on_piece_pass(int) TORRENT_OVERRIDE
void on_piece_pass(int) override
{
// if we became a seed, copy the metadata from
// the torrent before it is deallocated
@ -257,7 +257,7 @@ namespace libtorrent { namespace
metadata_plugin& operator=(metadata_plugin const&);
};
struct metadata_peer_plugin TORRENT_FINAL
struct metadata_peer_plugin final
: peer_plugin
{
metadata_peer_plugin(torrent& t, peer_connection& pc
@ -272,17 +272,17 @@ namespace libtorrent { namespace
, m_tp(tp)
{}
virtual char const* type() const TORRENT_OVERRIDE { return "LT_metadata"; }
virtual char const* type() const override { return "LT_metadata"; }
// can add entries to the extension handshake
virtual void add_handshake(entry& h) TORRENT_OVERRIDE
virtual void add_handshake(entry& h) override
{
entry& messages = h["m"];
messages["LT_metadata"] = 14;
}
// called when the extension handshake from the other end is received
virtual bool on_extension_handshake(bdecode_node const& h) TORRENT_OVERRIDE
virtual bool on_extension_handshake(bdecode_node const& h) override
{
m_message_index = 0;
if (h.type() != bdecode_node::dict_t) return false;
@ -389,7 +389,7 @@ namespace libtorrent { namespace
}
virtual bool on_extended(int length
, int msg, buffer::const_interval body) TORRENT_OVERRIDE
, int msg, buffer::const_interval body) override
{
if (msg != 14) return false;
if (m_message_index == 0) return false;
@ -491,7 +491,7 @@ namespace libtorrent { namespace
return true;
}
virtual void tick() TORRENT_OVERRIDE
virtual void tick() override
{
if (m_pc.is_disconnecting()) return;

6
src/smart_ban.cpp
View File

@ -118,7 +118,7 @@ namespace libtorrent {
namespace
{
struct smart_ban_plugin TORRENT_FINAL
struct smart_ban_plugin final
: torrent_plugin
, boost::enable_shared_from_this<smart_ban_plugin>
{
@ -136,7 +136,7 @@ namespace
{ fclose(m_log_file); }
#endif
virtual void on_piece_pass(int p) TORRENT_OVERRIDE
virtual void on_piece_pass(int p) override
{
#ifndef TORRENT_DISABLE_LOGGING
m_torrent.debug_log(" PIECE PASS [ p: %d | block_hash_size: %d ]"
@ -188,7 +188,7 @@ namespace
}
}
virtual void on_piece_failed(int p) TORRENT_OVERRIDE
virtual void on_piece_failed(int p) override
{
// The piece failed the hash check. Record
// the CRC and origin peer of every block

4
src/storage.cpp
View File

@ -234,7 +234,7 @@ namespace libtorrent
, boost::int64_t const file_offset
, int const size
, file::iovec_t const* bufs, storage_error& ec)
TORRENT_OVERRIDE TORRENT_FINAL
override final
{
if (m_storage.files().pad_file_at(file_index))
{
@ -325,7 +325,7 @@ namespace libtorrent
, boost::int64_t const file_offset
, int const size
, file::iovec_t const* bufs, storage_error& ec)
TORRENT_OVERRIDE TORRENT_FINAL
override final
{
int num_bufs = count_bufs(bufs, size);

24
src/ut_metadata.cpp
View File

@ -90,7 +90,7 @@ namespace libtorrent { namespace
struct ut_metadata_peer_plugin;
struct ut_metadata_plugin TORRENT_FINAL
struct ut_metadata_plugin final
: torrent_plugin
{
ut_metadata_plugin(torrent& t)
@ -106,19 +106,19 @@ namespace libtorrent { namespace
bool need_loaded()
{ return m_torrent.need_loaded(); }
virtual void on_unload() TORRENT_OVERRIDE
virtual void on_unload() override
{
m_metadata.reset();
}
virtual void on_load() TORRENT_OVERRIDE
virtual void on_load() override
{
// initialize m_metadata_size
TORRENT_ASSERT(m_torrent.is_loaded());
metadata();
}
virtual void on_files_checked() TORRENT_OVERRIDE
virtual void on_files_checked() override
{
// TODO: 2 if we were to initialize m_metadata_size lazily instead,
// we would probably be more efficient
@ -127,7 +127,7 @@ namespace libtorrent { namespace
}
virtual boost::shared_ptr<peer_plugin> new_connection(
peer_connection_handle const& pc) TORRENT_OVERRIDE;
peer_connection_handle const& pc) override;
int get_metadata_size() const
{
@ -167,7 +167,7 @@ namespace libtorrent { namespace
m_torrent.set_progress_ppm(boost::int64_t(m_metadata_progress) * 1000000 / m_metadata_size);
}
*/
void on_piece_pass(int) TORRENT_OVERRIDE
void on_piece_pass(int) override
{
// if we became a seed, copy the metadata from
// the torrent before it is deallocated
@ -215,7 +215,7 @@ namespace libtorrent { namespace
};
struct ut_metadata_peer_plugin TORRENT_FINAL
struct ut_metadata_peer_plugin final
: peer_plugin, boost::enable_shared_from_this<ut_metadata_peer_plugin>
{
friend struct ut_metadata_plugin;
@ -229,10 +229,10 @@ namespace libtorrent { namespace
, m_tp(tp)
{}
virtual char const* type() const TORRENT_OVERRIDE { return "ut_metadata"; }
virtual char const* type() const override { return "ut_metadata"; }
// can add entries to the extension handshake
virtual void add_handshake(entry& h) TORRENT_OVERRIDE
virtual void add_handshake(entry& h) override
{
entry& messages = h["m"];
messages["ut_metadata"] = 2;
@ -241,7 +241,7 @@ namespace libtorrent { namespace
}
// called when the extension handshake from the other end is received
virtual bool on_extension_handshake(bdecode_node const& h) TORRENT_OVERRIDE
virtual bool on_extension_handshake(bdecode_node const& h) override
{
m_message_index = 0;
if (h.type() != bdecode_node::dict_t) return false;
@ -327,7 +327,7 @@ namespace libtorrent { namespace
}
virtual bool on_extended(int length
, int extended_msg, buffer::const_interval body) TORRENT_OVERRIDE
, int extended_msg, buffer::const_interval body) override
{
if (extended_msg != 2) return false;
if (m_message_index == 0) return false;
@ -443,7 +443,7 @@ namespace libtorrent { namespace
return true;
}
virtual void tick() TORRENT_OVERRIDE
virtual void tick() override
{
maybe_send_request();
while (!m_incoming_requests.empty()

18
src/ut_pex.cpp
View File

@ -81,7 +81,7 @@ namespace libtorrent { namespace
return true;
}
struct ut_pex_plugin TORRENT_FINAL
struct ut_pex_plugin final
: torrent_plugin
{
// randomize when we rebuild the pex message
@ -94,7 +94,7 @@ namespace libtorrent { namespace
, m_peers_in_message(0) {}
virtual boost::shared_ptr<peer_plugin> new_connection(
peer_connection_handle const& pc) TORRENT_OVERRIDE;
peer_connection_handle const& pc) override;
std::vector<char>& get_ut_pex_msg()
{
@ -111,7 +111,7 @@ namespace libtorrent { namespace
// are calculated here and the pex message is created
// each peer connection will use this message
// max_peer_entries limits the packet size
virtual void tick() TORRENT_OVERRIDE
virtual void tick() override
{
time_point now = aux::time_now();
if (now - seconds(60) < m_last_msg) return;
@ -241,7 +241,7 @@ namespace libtorrent { namespace
ut_pex_plugin& operator=(ut_pex_plugin const&);
};
struct ut_pex_peer_plugin TORRENT_FINAL
struct ut_pex_peer_plugin final
: peer_plugin
{
ut_pex_peer_plugin(torrent& t, peer_connection& pc, ut_pex_plugin& tp)
@ -259,15 +259,15 @@ namespace libtorrent { namespace
}
}
virtual char const* type() const TORRENT_OVERRIDE { return "ut_pex"; }
virtual char const* type() const override { return "ut_pex"; }
virtual void add_handshake(entry& h) TORRENT_OVERRIDE
virtual void add_handshake(entry& h) override
{
entry& messages = h["m"];
messages[extension_name] = extension_index;
}
virtual bool on_extension_handshake(bdecode_node const& h) TORRENT_OVERRIDE
virtual bool on_extension_handshake(bdecode_node const& h) override
{
m_message_index = 0;
if (h.type() != bdecode_node::dict_t) return false;
@ -280,7 +280,7 @@ namespace libtorrent { namespace
return true;
}
virtual bool on_extended(int length, int msg, buffer::const_interval body) TORRENT_OVERRIDE
virtual bool on_extended(int length, int msg, buffer::const_interval body) override
{
if (msg != extension_index) return false;
if (m_message_index == 0) return false;
@ -433,7 +433,7 @@ namespace libtorrent { namespace
// the peers second tick
// every minute we send a pex message
virtual void tick() TORRENT_OVERRIDE
virtual void tick() override
{
// no handshake yet
if (!m_message_index) return;

22
test/test_block_cache.cpp
View File

@ -47,33 +47,33 @@ using namespace libtorrent;
struct test_storage_impl : storage_interface
{
virtual void initialize(storage_error& ec) TORRENT_OVERRIDE {}
virtual void initialize(storage_error& ec) override {}
virtual int readv(file::iovec_t const* bufs, int num_bufs
, int piece, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE
, int piece, int offset, int flags, storage_error& ec) override
{
return bufs_size(bufs, num_bufs);
}
virtual int writev(file::iovec_t const* bufs, int num_bufs
, int piece, int offset, int flags, storage_error& ec) TORRENT_OVERRIDE
, int piece, int offset, int flags, storage_error& ec) override
{
return bufs_size(bufs, num_bufs);
}
virtual bool has_any_file(storage_error& ec) TORRENT_OVERRIDE { return false; }
virtual bool has_any_file(storage_error& ec) override { return false; }
virtual void set_file_priority(std::vector<boost::uint8_t> const& prio
, storage_error& ec) TORRENT_OVERRIDE {}
, storage_error& ec) override {}
virtual int move_storage(std::string const& save_path, int flags
, storage_error& ec) TORRENT_OVERRIDE { return 0; }
, storage_error& ec) override { return 0; }
virtual bool verify_resume_data(add_torrent_params const& rd
, std::vector<std::string> const* links
, storage_error& ec) TORRENT_OVERRIDE { return true; }
virtual void release_files(storage_error& ec) TORRENT_OVERRIDE {}
, storage_error& ec) override { return true; }
virtual void release_files(storage_error& ec) override {}
virtual void rename_file(int index, std::string const& new_filenamem
, storage_error& ec) TORRENT_OVERRIDE {}
virtual void delete_files(int, storage_error& ec) TORRENT_OVERRIDE {}
, storage_error& ec) override {}
virtual void delete_files(int, storage_error& ec) override {}
#ifndef TORRENT_NO_DEPRECATE
virtual void finalize_file(int, storage_error&) TORRENT_OVERRIDE {}
virtual void finalize_file(int, storage_error&) override {}
#endif
};

22
test/test_dht.cpp
View File

@ -95,10 +95,10 @@ static void nop(void* userdata, libtorrent::dht::node_entry const& n) {}
std::list<std::pair<udp::endpoint, entry> > g_sent_packets;
struct mock_socket TORRENT_FINAL : udp_socket_interface
struct mock_socket final : udp_socket_interface
{
bool has_quota() TORRENT_OVERRIDE { return true; }
bool send_packet(entry& msg, udp::endpoint const& ep) TORRENT_OVERRIDE
bool has_quota() override { return true; }
bool send_packet(entry& msg, udp::endpoint const& ep) override
{
// TODO: ideally the mock_socket would contain this queue of packets, to
// make tests independent
@ -476,18 +476,18 @@ void put_immutable_item_cb(int num, int expect)
struct obs : dht::dht_observer
{
virtual void set_external_address(address const& addr
, address const& source) TORRENT_OVERRIDE
, address const& source) override
{}
virtual address external_address(udp proto) TORRENT_OVERRIDE
virtual address external_address(udp proto) override
{
return address_v4::from_string("236.0.0.1");
}
virtual void get_peers(sha1_hash const& ih) TORRENT_OVERRIDE {}
virtual void get_peers(sha1_hash const& ih) override {}
virtual void outgoing_get_peers(sha1_hash const& target
, sha1_hash const& sent_target, udp::endpoint const& ep) TORRENT_OVERRIDE {}
virtual void announce(sha1_hash const& ih, address const& addr, int port) TORRENT_OVERRIDE {}
virtual void log(dht_logger::module_t l, char const* fmt, ...) TORRENT_OVERRIDE
, sha1_hash const& sent_target, udp::endpoint const& ep) override {}
virtual void announce(sha1_hash const& ih, address const& addr, int port) override {}
virtual void log(dht_logger::module_t l, char const* fmt, ...) override
{
va_list v;
va_start(v, fmt);
@ -497,9 +497,9 @@ struct obs : dht::dht_observer
m_log.push_back(buf);
}
virtual void log_packet(message_direction_t dir, char const* pkt, int len
, udp::endpoint node) TORRENT_OVERRIDE {}
, udp::endpoint node) override {}
virtual bool on_dht_request(char const* query, int query_len
, dht::msg const& request, entry& response) TORRENT_OVERRIDE { return false; }
, dht::msg const& request, entry& response) override { return false; }
std::vector<std::string> m_log;
};

4
test/test_dos_blocker.cpp
View File

@ -45,7 +45,7 @@ using namespace libtorrent;
struct log_t : libtorrent::dht::dht_logger
{
virtual void log(dht_logger::module_t m, char const* fmt, ...)
TORRENT_OVERRIDE TORRENT_FORMAT(3, 4)
override TORRENT_FORMAT(3, 4)
{
va_list v;
va_start(v, fmt);
@ -54,7 +54,7 @@ struct log_t : libtorrent::dht::dht_logger
}
virtual void log_packet(message_direction_t dir, char const* pkt, int len
, udp::endpoint node) TORRENT_OVERRIDE
, udp::endpoint node) override
{
libtorrent::bdecode_node print;
libtorrent::error_code ec;