diff --git a/include/libtorrent/torrent_status.hpp b/include/libtorrent/torrent_status.hpp index dec0a3e72..3585a58bd 100644 --- a/include/libtorrent/torrent_status.hpp +++ b/include/libtorrent/torrent_status.hpp @@ -124,7 +124,8 @@ namespace libtorrent std::string _dummy_string_; #endif error_code errc; - int error_file; + + int error_file = torrent_status::error_file_none; // special values for error_file to describe which file or component // encountered the error (``errc``). @@ -168,7 +169,7 @@ namespace libtorrent std::weak_ptr torrent_file; // the time until the torrent will announce itself to the tracker. - time_duration next_announce; + time_duration next_announce = seconds(0); #ifndef TORRENT_NO_DEPRECATE // the time the tracker want us to wait until we announce ourself @@ -188,22 +189,22 @@ namespace libtorrent // torrent is paused and restarted again. When a torrent is paused, these // counters are reset to 0. If you want complete, persistent, stats, see // ``all_time_upload`` and ``all_time_download``. - std::int64_t total_download; - std::int64_t total_upload; + std::int64_t total_download = 0; + std::int64_t total_upload = 0; // counts the amount of bytes send and received this session, but only // the actual payload data (i.e the interesting data), these counters // ignore any protocol overhead. The session is considered to restart // when a torrent is paused and restarted again. When a torrent is // paused, these counters are reset to 0. - std::int64_t total_payload_download; - std::int64_t total_payload_upload; + std::int64_t total_payload_download = 0; + std::int64_t total_payload_upload = 0; // the number of bytes that has been downloaded and that has failed the // piece hash test. In other words, this is just how much crap that has // been downloaded since the torrent was last started. If a torrent is // paused and then restarted again, this counter will be reset. - std::int64_t total_failed_bytes; + std::int64_t total_failed_bytes = 0; // the number of bytes that has been downloaded even though that data // already was downloaded. The reason for this is that in some situations @@ -216,7 +217,7 @@ namespace libtorrent // low as possible. This only counts bytes since the torrent was last // started. If a torrent is paused and then restarted again, this counter // will be reset. - std::int64_t total_redundant_bytes; + std::int64_t total_redundant_bytes = 0; // a bitmask that represents which pieces we have (set to true) and the // pieces we don't have. It's a pointer and may be set to 0 if the @@ -231,42 +232,42 @@ namespace libtorrent // the total number of bytes of the file(s) that we have. All this does // not necessarily has to be downloaded during this session (that's // ``total_payload_download``). - std::int64_t total_done; + std::int64_t total_done = 0; // the number of bytes we have downloaded, only counting the pieces that // we actually want to download. i.e. excluding any pieces that we have // but have priority 0 (i.e. not wanted). - std::int64_t total_wanted_done; + std::int64_t total_wanted_done = 0; // The total number of bytes we want to download. This may be smaller // than the total torrent size in case any pieces are prioritized to 0, // i.e. not wanted - std::int64_t total_wanted; + std::int64_t total_wanted = 0; // are accumulated upload and download payload byte counters. They are // saved in and restored from resume data to keep totals across sessions. - std::int64_t all_time_upload; - std::int64_t all_time_download; + std::int64_t all_time_upload = 0; + std::int64_t all_time_download = 0; // the posix-time when this torrent was added. i.e. what ``time(nullptr)`` // returned at the time. - time_t added_time; + time_t added_time = 0; // the posix-time when this torrent was finished. If the torrent is not // yet finished, this is 0. - time_t completed_time; + time_t completed_time = 0; // the time when we, or one of our peers, last saw a complete copy of // this torrent. - time_t last_seen_complete; + time_t last_seen_complete = 0; // The allocation mode for the torrent. See storage_mode_t for the // options. For more information, see storage-allocation_. - storage_mode_t storage_mode; + storage_mode_t storage_mode = storage_mode_sparse; // a value in the range [0, 1], that represents the progress of the // torrent's current task. It may be checking files or downloading. - float progress; + float progress = 0.f; // progress parts per million (progress * 1000000) when disabling // floating point operations, this is the only option to query progress @@ -275,66 +276,66 @@ namespace libtorrent // 1000000] (ppm = parts per million). When floating point operations are // disabled, this is the only alternative to the floating point value in // progress. - int progress_ppm; + int progress_ppm = 0; // the position this torrent has in the download // queue. If the torrent is a seed or finished, this is -1. - int queue_position; + int queue_position = 0; // the total rates for all peers for this torrent. These will usually // have better precision than summing the rates from all peers. The rates // are given as the number of bytes per second. - int download_rate; - int upload_rate; + int download_rate = 0; + int upload_rate = 0; // the total transfer rate of payload only, not counting protocol // chatter. This might be slightly smaller than the other rates, but if // projected over a long time (e.g. when calculating ETA:s) the // difference may be noticeable. - int download_payload_rate; - int upload_payload_rate; + int download_payload_rate = 0; + int upload_payload_rate = 0; // the number of peers that are seeding that this client is // currently connected to. - int num_seeds; + int num_seeds = 0; // the number of peers this torrent currently is connected to. Peer // connections that are in the half-open state (is attempting to connect) // or are queued for later connection attempt do not count. Although they // are visible in the peer list when you call get_peer_info(). - int num_peers; + int num_peers = 0; // if the tracker sends scrape info in its announce reply, these fields // will be set to the total number of peers that have the whole file and // the total number of peers that are still downloading. set to -1 if the // tracker did not send any scrape data in its announce reply. - int num_complete; - int num_incomplete; + int num_complete = -1; + int num_incomplete = -1; // the number of seeds in our peer list and the total number of peers // (including seeds). We are not necessarily connected to all the peers // in our peer list. This is the number of peers we know of in total, // including banned peers and peers that we have failed to connect to. - int list_seeds; - int list_peers; + int list_seeds = 0; + int list_peers = 0; // the number of peers in this torrent's peer list that is a candidate to // be connected to. i.e. It has fewer connect attempts than the max fail // count, it is not a seed if we are a seed, it is not banned etc. If // this is 0, it means we don't know of any more peers that we can try. - int connect_candidates; + int connect_candidates = 0; // the number of pieces that has been downloaded. It is equivalent to: // ``std::accumulate(pieces->begin(), pieces->end())``. So you don't have // to count yourself. This can be used to see if anything has updated // since last time if you want to keep a graph of the pieces up to date. - int num_pieces; + int num_pieces = 0; // the number of distributed copies of the torrent. Note that one copy // may be spread out among many peers. It tells how many copies there are // currently of the rarest piece(s) among the peers this client is // connected to. - int distributed_full_copies; + int distributed_full_copies = 0; // tells the share of pieces that have more copies than the rarest // piece(s). Divide this number by 1000 to get the fraction. @@ -347,7 +348,7 @@ namespace libtorrent // If we are a seed, the piece picker is deallocated as an optimization, // and piece availability is no longer tracked. In this case the // distributed copies members are set to -1. - int distributed_fraction; + int distributed_fraction = 0; // the number of distributed copies of the file. note that one copy may // be spread out among many peers. This is a floating point @@ -358,28 +359,28 @@ namespace libtorrent // // the fractional part tells the fraction of pieces that // have more copies than the rarest piece(s). - float distributed_copies; + float distributed_copies = 0.f; // the size of a block, in bytes. A block is a sub piece, it is the // number of bytes that each piece request asks for and the number of // bytes that each bit in the ``partial_piece_info``'s bitset represents, // see get_download_queue(). This is typically 16 kB, but it may be // larger if the pieces are larger. - int block_size; + int block_size = 0; // the number of unchoked peers in this torrent. - int num_uploads; + int num_uploads = 0; // the number of peer connections this torrent has, including half-open // connections that hasn't completed the bittorrent handshake yet. This // is always >= ``num_peers``. - int num_connections; + int num_connections = 0; // the set limit of upload slots (unchoked peers) for this torrent. - int uploads_limit; + int uploads_limit = 0; // the set limit of number of connections for this torrent. - int connections_limit; + int connections_limit = 0; // the number of peers in this torrent that are waiting for more // bandwidth quota from the torrent rate limiter. This can determine if @@ -387,8 +388,8 @@ namespace libtorrent // not. If there is no limit set on this torrent, the peers might still // be waiting for bandwidth quota from the global limiter, but then they // are counted in the ``session_status`` object. - int up_bandwidth_queue; - int down_bandwidth_queue; + int up_bandwidth_queue = 0; + int down_bandwidth_queue = 0; // the number of seconds since any peer last uploaded from this torrent // and the last time a downloaded piece passed the hash check, @@ -397,8 +398,8 @@ namespace libtorrent // purpose of this counter. -1 means there either hasn't been any // uploading/downloading, or it was too long ago for libtorrent to // remember (currently forgetting happens after about 18 hours) - int time_since_upload; - int time_since_download; + int time_since_upload = 0; + int time_since_download = 0; // These keep track of the number of seconds this torrent has been active // (not paused) and the number of seconds it has been active while being @@ -406,39 +407,39 @@ namespace libtorrent // ``finished_time`` which should be <= ``active_time``. They are all // saved in and restored from resume data, to keep totals across // sessions. - int active_time; - int finished_time; - int seeding_time; + int active_time = 0; + int finished_time = 0; + int seeding_time = 0; // A rank of how important it is to seed the torrent, it is used to // determine which torrents to seed and which to queue. It is based on // the peer to seed ratio from the tracker scrape. For more information, // see queuing_. Higher value means more important to seed - int seed_rank; + int seed_rank = 0; // the number of seconds since this torrent acquired scrape data. // If it has never done that, this value is -1. - int last_scrape; + int last_scrape = 0; #ifndef TORRENT_NO_DEPRECATE // the priority of this torrent - int priority; + int priority = 0; #else // hidden - int deprecated_priority; + int deprecated_priority = 0; #endif // the main state the torrent is in. See torrent_status::state_t. - state_t state; + state_t state = checking_resume_data; // true if this torrent has unsaved changes // to its download state and statistics since the last resume data // was saved. - bool need_save_resume; + bool need_save_resume = false; // true if the session global IP filter applies // to this torrent. This defaults to true. - bool ip_filter_applies; + bool ip_filter_applies = false; // true if the torrent is blocked from downloading. This typically // happens when a disk write operation fails. If the torrent is @@ -447,65 +448,65 @@ namespace libtorrent // has been resolved. If the torrent is not auto-managed, you have to // explicitly take it out of the upload mode by calling set_upload_mode() // on the torrent_handle. - bool upload_mode; + bool upload_mode = false; // true if the torrent is currently in share-mode, i.e. not downloading // the torrent, but just helping the swarm out. - bool share_mode; + bool share_mode = false; // true if the torrent is in super seeding mode - bool super_seeding; + bool super_seeding = false; // set to true if the torrent is paused and false otherwise. It's only // true if the torrent itself is paused. If the torrent is not running // because the session is paused, this is still false. To know if a // torrent is active or not, you need to inspect both // ``torrent_status::paused`` and ``session::is_paused()``. - bool paused; + bool paused = false; // set to true if the torrent is auto managed, i.e. libtorrent is // responsible for determining whether it should be started or queued. // For more info see queuing_ - bool auto_managed; + bool auto_managed = false; // true when the torrent is in sequential download mode. In this mode // pieces are downloaded in order rather than rarest first. - bool sequential_download; + bool sequential_download = false; // true if all pieces have been downloaded. - bool is_seeding; + bool is_seeding = false; // true if all pieces that have a priority > 0 are downloaded. There is // only a distinction between finished and seeding if some pieces or // files have been set to priority 0, i.e. are not downloaded. - bool is_finished; + bool is_finished = false; // true if this torrent has metadata (either it was started from a // .torrent file or the metadata has been downloaded). The only scenario // where this can be false is when the torrent was started torrent-less // (i.e. with just an info-hash and tracker ip, a magnet link for // instance). - bool has_metadata; + bool has_metadata = false; // true if there has ever been an incoming connection attempt to this // torrent. - bool has_incoming; + bool has_incoming = false; // true if the torrent is in seed_mode. If the torrent was started in // seed mode, it will leave seed mode once all pieces have been checked // or as soon as one piece fails the hash check. - bool seed_mode; + bool seed_mode = false; // this is true if this torrent's storage is currently being moved from // one location to another. This may potentially be a long operation // if a large file ends up being copied from one drive to another. - bool moving_storage; + bool moving_storage = false; #ifndef TORRENT_NO_DEPRECATE // true if this torrent is loaded into RAM. A torrent can be started // and still not loaded into RAM, in case it has not had any peers interested in it // yet. Torrents are loaded on demand. - bool is_loaded; + bool is_loaded = false; #else // hidden bool deprecated_is_loaded; @@ -515,19 +516,18 @@ namespace libtorrent // respective peer source. Whether they are true or false is determined by // the queue logic/auto manager. Torrents that are not auto managed will // always be allowed to announce to all peer sources. - bool announcing_to_trackers; - bool announcing_to_lsd; - bool announcing_to_dht; + bool announcing_to_trackers = false; + bool announcing_to_lsd = false; + bool announcing_to_dht = false; // this reflects whether the ``stop_when_ready`` flag is currently enabled // on this torrent. For more information, see // torrent_handle::stop_when_ready(). - bool stop_when_ready; + bool stop_when_ready = false; // the info-hash for this torrent - sha1_hash info_hash; + sha1_hash info_hash{nullptr}; }; - } namespace std diff --git a/src/torrent_status.cpp b/src/torrent_status.cpp index 787dbfb55..a837b6fe0 100644 --- a/src/torrent_status.cpp +++ b/src/torrent_status.cpp @@ -34,85 +34,7 @@ POSSIBILITY OF SUCH DAMAGE. namespace libtorrent { - torrent_status::torrent_status() - : error_file(torrent_status::error_file_none) - , next_announce(seconds(0)) - , total_download(0) - , total_upload(0) - , total_payload_download(0) - , total_payload_upload(0) - , total_failed_bytes(0) - , total_redundant_bytes(0) - , total_done(0) - , total_wanted_done(0) - , total_wanted(0) - , all_time_upload(0) - , all_time_download(0) - , added_time(0) - , completed_time(0) - , last_seen_complete(0) - , storage_mode(storage_mode_sparse) - , progress(0.f) - , progress_ppm(0) - , queue_position(0) - , download_rate(0) - , upload_rate(0) - , download_payload_rate(0) - , upload_payload_rate(0) - , num_seeds(0) - , num_peers(0) - , num_complete(-1) - , num_incomplete(-1) - , list_seeds(0) - , list_peers(0) - , connect_candidates(0) - , num_pieces(0) - , distributed_full_copies(0) - , distributed_fraction(0) - , distributed_copies(0.f) - , block_size(0) - , num_uploads(0) - , num_connections(0) - , uploads_limit(0) - , connections_limit(0) - , up_bandwidth_queue(0) - , down_bandwidth_queue(0) - , time_since_upload(0) - , time_since_download(0) - , active_time(0) - , finished_time(0) - , seeding_time(0) - , seed_rank(0) - , last_scrape(0) -#ifndef TORRENT_NO_DEPRECATE - , priority(0) -#endif - , state(checking_resume_data) - , need_save_resume(false) - , ip_filter_applies(true) - , upload_mode(false) - , share_mode(false) - , super_seeding(false) - , paused(false) - , auto_managed(false) - , sequential_download(false) - , is_seeding(false) - , is_finished(false) - , has_metadata(false) - , has_incoming(false) - , seed_mode(false) - , moving_storage(false) -#ifndef TORRENT_NO_DEPRECATE - , is_loaded(true) -#endif - , announcing_to_trackers(false) - , announcing_to_lsd(false) - , announcing_to_dht(false) - , stop_when_ready(false) - , info_hash(nullptr) - {} - + torrent_status::torrent_status() = default; torrent_status::~torrent_status() = default; - }