--- /srv/reproducible-results/rbuild-debian/r-b-build.4z8V1O8x/b1/libtorrent-rasterbar_2.0.11-1_arm64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.4z8V1O8x/b2/libtorrent-rasterbar_2.0.11-1_arm64.changes ├── Files │ @@ -1,7 +1,7 @@ │ │ 8879bb4196c7494bdc732b50c9654f4d 366352 libdevel optional libtorrent-rasterbar-dev_2.0.11-1_arm64.deb │ - dc6da2fe482bf3fa338a962eb4db5380 1669656 doc optional libtorrent-rasterbar-doc_2.0.11-1_all.deb │ + f86f982462e6270113727140a6d22c8c 1669436 doc optional libtorrent-rasterbar-doc_2.0.11-1_all.deb │ 220f1099320838195f1ba79e43a09163 50639100 debug optional libtorrent-rasterbar2.0t64-dbgsym_2.0.11-1_arm64.deb │ 60284f8274587a23f3b6e623b878fccb 1493216 libs optional libtorrent-rasterbar2.0t64_2.0.11-1_arm64.deb │ 4f5e56b44de73ad776c95c638d36d70f 13135524 debug optional python3-libtorrent-dbgsym_2.0.11-1_arm64.deb │ 3b27af54af689f5e5e84db3b39ce6e97 673060 python optional python3-libtorrent_2.0.11-1_arm64.deb ├── libtorrent-rasterbar-doc_2.0.11-1_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2025-01-28 14:33:12.000000 debian-binary │ │ --rw-r--r-- 0 0 0 3632 2025-01-28 14:33:12.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 1665832 2025-01-28 14:33:12.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 3628 2025-01-28 14:33:12.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 1665616 2025-01-28 14:33:12.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Add_Torrent.html │ │ │ │ @@ -30,15 +30,15 @@ │ │ │ │ │ │ │ │

home

│ │ │ │
│ │ │ │

Table of contents

│ │ │ │ │ │ │ │
│ │ │ │ [report issue]
│ │ │ │

client_data_t

│ │ │ │ @@ -51,37 +51,37 @@ │ │ │ │ { │ │ │ │ client_data_t () = default; │ │ │ │ explicit client_data_t (T* v); │ │ │ │ client_data_t& operator= (T* v); │ │ │ │ T* get () const; │ │ │ │ explicit operator T () const; │ │ │ │ operator void* () const = delete; │ │ │ │ - operator void const* () const = delete; │ │ │ │ - client_data_t& operator= (void*) = delete; │ │ │ │ client_data_t& operator= (void const*) = delete; │ │ │ │ + client_data_t& operator= (void*) = delete; │ │ │ │ + operator void const* () const = delete; │ │ │ │ │ │ │ │ template <typename T, typename U = typename std::enable_if<std::is_pointer<T>::value>::type> │ │ │ │ }; │ │ │ │ │ │ │ │ [report issue]
│ │ │ │

client_data_t()

│ │ │ │ 
│ │ │ │  client_data_t () = default;
│ │ │ │
│ │ │ │

construct a nullptr client data

│ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
│ │ │ │ -
│ │ │ │ -

const*() void*() operator=()

│ │ │ │ + │ │ │ │ +[report issue]
│ │ │ │ +
│ │ │ │ +

const*() operator=() void*()

│ │ │ │ 
│ │ │ │  operator void* () const = delete;
│ │ │ │ -operator void const* () const = delete;
│ │ │ │ -client_data_t& operator= (void*) = delete;
│ │ │ │  client_data_t& operator= (void const*) = delete;
│ │ │ │ +client_data_t& operator= (void*) = delete;
│ │ │ │ +operator void const* () const = delete;
│ │ │ │
│ │ │ │

we don't allow type-unsafe operations

│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
│ │ │ │

add_torrent_params

│ │ │ │

Declared in "libtorrent/add_torrent_params.hpp"

│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ > │ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_] │ │ │ │ │ VVeerrssiioonn:: 2.0.11 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _c_l_i_e_n_t___d_a_t_a___t │ │ │ │ │ o _c_l_i_e_n_t___d_a_t_a___t_(_) │ │ │ │ │ - o _c_o_n_s_t_*_(_)_ _v_o_i_d_*_(_)_ _o_p_e_r_a_t_o_r_=_(_) │ │ │ │ │ + o _c_o_n_s_t_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _v_o_i_d_*_(_) │ │ │ │ │ * _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ cclliieenntt__ddaattaa__tt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_l_i_e_n_t___d_a_t_a_._h_p_p" │ │ │ │ │ A thin wrapper around a void pointer used as "user data". i.e. an opaque cookie │ │ │ │ │ passed in to libtorrent and returned on demand. It adds type-safety by │ │ │ │ │ requiring the same type be requested out of it as was assigned to it. │ │ │ │ │ @@ -17,31 +17,31 @@ │ │ │ │ │ { │ │ │ │ │ cclliieenntt__ddaattaa__tt () = default; │ │ │ │ │ explicit cclliieenntt__ddaattaa__tt (T* v); │ │ │ │ │ client_data_t& ooppeerraattoorr== (T* v); │ │ │ │ │ T* ggeett () const; │ │ │ │ │ explicit operator TT () const; │ │ │ │ │ operator vvooiidd** () const = delete; │ │ │ │ │ - operator void ccoonnsstt** () const = delete; │ │ │ │ │ - client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete; │ │ │ │ │ + client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ + operator void ccoonnsstt** () const = delete; │ │ │ │ │ │ │ │ │ │ template ::value>::type> │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** cclliieenntt__ddaattaa__tt(()) ********** │ │ │ │ │ cclliieenntt__ddaattaa__tt () = default; │ │ │ │ │ construct a nullptr client data │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ccoonnsstt**(()) vvooiidd**(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ +********** ccoonnsstt**(()) ooppeerraattoorr==(()) vvooiidd**(()) ********** │ │ │ │ │ operator vvooiidd** () const = delete; │ │ │ │ │ -operator void ccoonnsstt** () const = delete; │ │ │ │ │ -client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete; │ │ │ │ │ +client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ +operator void ccoonnsstt** () const = delete; │ │ │ │ │ we don't allow type-unsafe operations │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ aadddd__ttoorrrreenntt__ppaarraammss ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s_._h_p_p" │ │ │ │ │ The _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s contains all the information in a .torrent file along │ │ │ │ │ with all information necessary to add that torrent to a _s_e_s_s_i_o_n. The key fields │ │ │ │ │ when adding a torrent are: │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Alerts.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -544,27 +544,27 @@ │ │ │ │

Declared in "libtorrent/alert_types.hpp"

│ │ │ │

This is posted as a response to a torrent_handle::rename_file() call, if the rename │ │ │ │ operation succeeds.

│ │ │ │ 
│ │ │ │  struct file_renamed_alert final : torrent_alert
│ │ │ │  {
│ │ │ │     std::string message () const override;
│ │ │ │ -   char const* new_name () const;
│ │ │ │     char const* old_name () const;
│ │ │ │ +   char const* new_name () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::storage;
│ │ │ │     file_index_t const index;
│ │ │ │  };
│ │ │ │
│ │ │ │ │ │ │ │ [report issue]
│ │ │ │

old_name() new_name()

│ │ │ │ 
│ │ │ │ -char const* new_name () const;
│ │ │ │  char const* old_name () const;
│ │ │ │ +char const* new_name () const;
│ │ │ │
│ │ │ │

returns the new and previous file name, respectively.

│ │ │ │ [report issue]
│ │ │ │
index
│ │ │ │
refers to the index of the file that was renamed,
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ @@ -1287,26 +1287,26 @@ │ │ │ │ torrent_handle::move_storage. This is useful to synchronize with the │ │ │ │ actual disk. The storage_path() member return the new path of the │ │ │ │ storage.

│ │ │ │ 
│ │ │ │  struct storage_moved_alert final : torrent_alert
│ │ │ │  {
│ │ │ │     std::string message () const override;
│ │ │ │ -   char const* storage_path () const;
│ │ │ │     char const* old_path () const;
│ │ │ │ +   char const* storage_path () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::storage;
│ │ │ │  };
│ │ │ │
│ │ │ │ │ │ │ │ [report issue]
│ │ │ │

storage_path() old_path()

│ │ │ │ 
│ │ │ │ -char const* storage_path () const;
│ │ │ │  char const* old_path () const;
│ │ │ │ +char const* storage_path () const;
│ │ │ │
│ │ │ │

the path the torrent was moved to and from, respectively.

│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
│ │ │ │

storage_moved_failed_alert

│ │ │ │

Declared in "libtorrent/alert_types.hpp"

│ │ │ │ @@ -2944,27 +2944,27 @@ │ │ │ │

posted in response to a call to session::dht_live_nodes(). It contains the │ │ │ │ live nodes from the DHT routing table of one of the DHT nodes running │ │ │ │ locally.

│ │ │ │ 
│ │ │ │  struct dht_live_nodes_alert final : alert
│ │ │ │  {
│ │ │ │     std::string message () const override;
│ │ │ │ -   int num_nodes () const;
│ │ │ │     std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │ +   int num_nodes () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::dht;
│ │ │ │     sha1_hash node_id;
│ │ │ │  };
│ │ │ │
│ │ │ │ │ │ │ │ [report issue]
│ │ │ │

num_nodes() nodes()

│ │ │ │ 
│ │ │ │ -int num_nodes () const;
│ │ │ │  std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │ +int num_nodes () const;
│ │ │ │
│ │ │ │

the number of nodes in the routing table and the actual nodes.

│ │ │ │ [report issue]
│ │ │ │
node_id
│ │ │ │
the local DHT node's node-ID this routing table belongs to
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ @@ -2993,32 +2993,32 @@ │ │ │ │

Declared in "libtorrent/alert_types.hpp"

│ │ │ │

posted as a response to a call to session::dht_sample_infohashes() with │ │ │ │ the information from the DHT response message.

│ │ │ │ 
│ │ │ │  struct dht_sample_infohashes_alert final : alert
│ │ │ │  {
│ │ │ │     std::string message () const override;
│ │ │ │ -   std::vector<sha1_hash> samples () const;
│ │ │ │     int num_samples () const;
│ │ │ │ +   std::vector<sha1_hash> samples () const;
│ │ │ │     int num_nodes () const;
│ │ │ │     std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::dht_operation;
│ │ │ │     sha1_hash node_id;
│ │ │ │     aux::noexcept_movable<udp::endpoint> endpoint;
│ │ │ │     time_duration const interval;
│ │ │ │     int const num_infohashes;
│ │ │ │  };
│ │ │ │
│ │ │ │ │ │ │ │ [report issue]
│ │ │ │

samples() num_samples()

│ │ │ │ 
│ │ │ │ -std::vector<sha1_hash> samples () const;
│ │ │ │  int num_samples () const;
│ │ │ │ +std::vector<sha1_hash> samples () const;
│ │ │ │
│ │ │ │

returns the number of info-hashes returned by the node, as well as the │ │ │ │ actual info-hashes. num_samples() is more efficient than │ │ │ │ samples().size().

│ │ │ │ [report issue]
│ │ │ │
│ │ │ │

num_nodes()

│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -400,25 +400,25 @@ │ │ │ │ │ ************ ffiillee__rreennaammeedd__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ This is posted as a response to a _t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_r_e_n_a_m_e___f_i_l_e_(_) call, if the │ │ │ │ │ rename operation succeeds. │ │ │ │ │ struct file_renamed_alert final : torrent_alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - char const* nneeww__nnaammee () const; │ │ │ │ │ char const* oolldd__nnaammee () const; │ │ │ │ │ + char const* nneeww__nnaammee () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ storage; │ │ │ │ │ file_index_t const index; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** oolldd__nnaammee(()) nneeww__nnaammee(()) ********** │ │ │ │ │ -char const* nneeww__nnaammee () const; │ │ │ │ │ char const* oolldd__nnaammee () const; │ │ │ │ │ +char const* nneeww__nnaammee () const; │ │ │ │ │ returns the new and previous file name, respectively. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ index │ │ │ │ │ refers to the index of the file that was renamed, │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ffiillee__rreennaammee__ffaaiilleedd__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ @@ -1035,24 +1035,24 @@ │ │ │ │ │ The storage_moved_alert is generated when all the disk IO has completed and the │ │ │ │ │ files have been moved, as an effect of a call to torrent_handle::move_storage. │ │ │ │ │ This is useful to synchronize with the actual disk. The storage_path() member │ │ │ │ │ return the new path of the storage. │ │ │ │ │ struct storage_moved_alert final : torrent_alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ char const* oolldd__ppaatthh () const; │ │ │ │ │ + char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ storage; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ssttoorraaggee__ppaatthh(()) oolldd__ppaatthh(()) ********** │ │ │ │ │ -char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ char const* oolldd__ppaatthh () const; │ │ │ │ │ +char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ the path the torrent was moved to and from, respectively. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ssttoorraaggee__mmoovveedd__ffaaiilleedd__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ The storage_moved_failed_alert is generated when an attempt to move the │ │ │ │ │ storage, via _t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_m_o_v_e___s_t_o_r_a_g_e_(_), fails. │ │ │ │ │ struct storage_moved_failed_alert final : torrent_alert │ │ │ │ │ @@ -2288,24 +2288,24 @@ │ │ │ │ │ ************ ddhhtt__lliivvee__nnooddeess__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ posted in response to a call to session::dht_live_nodes(). It contains the live │ │ │ │ │ nodes from the DHT routing table of one of the DHT nodes running locally. │ │ │ │ │ struct dht_live_nodes_alert final : alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - int nnuumm__nnooddeess () const; │ │ │ │ │ std::vector> nnooddeess () const; │ │ │ │ │ + int nnuumm__nnooddeess () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category::dht; │ │ │ │ │ sha1_hash node_id; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnuumm__nnooddeess(()) nnooddeess(()) ********** │ │ │ │ │ -int nnuumm__nnooddeess () const; │ │ │ │ │ std::vector> nnooddeess () const; │ │ │ │ │ +int nnuumm__nnooddeess () const; │ │ │ │ │ the number of nodes in the routing table and the actual nodes. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ node_id │ │ │ │ │ the local DHT node's node-ID this routing table belongs to │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseessssiioonn__ssttaattss__hheeaaddeerr__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ @@ -2326,30 +2326,30 @@ │ │ │ │ │ ************ ddhhtt__ssaammppllee__iinnffoohhaasshheess__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ posted as a response to a call to session::dht_sample_infohashes() with the │ │ │ │ │ information from the DHT response message. │ │ │ │ │ struct dht_sample_infohashes_alert final : alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - std::vector ssaammpplleess () const; │ │ │ │ │ int nnuumm__ssaammpplleess () const; │ │ │ │ │ + std::vector ssaammpplleess () const; │ │ │ │ │ int nnuumm__nnooddeess () const; │ │ │ │ │ std::vector> nnooddeess () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ dht_operation; │ │ │ │ │ sha1_hash node_id; │ │ │ │ │ aux::noexcept_movable endpoint; │ │ │ │ │ time_duration const interval; │ │ │ │ │ int const num_infohashes; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ssaammpplleess(()) nnuumm__ssaammpplleess(()) ********** │ │ │ │ │ -std::vector ssaammpplleess () const; │ │ │ │ │ int nnuumm__ssaammpplleess () const; │ │ │ │ │ +std::vector ssaammpplleess () const; │ │ │ │ │ returns the number of info-hashes returned by the node, as well as the actual │ │ │ │ │ info-hashes. num_samples() is more efficient than samples().size(). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnuumm__nnooddeess(()) ********** │ │ │ │ │ int nnuumm__nnooddeess () const; │ │ │ │ │ The total number of nodes returned by nodes(). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Bdecoding.html │ │ │ │ @@ -30,23 +30,23 @@ │ │ │ │ │ │ │ │

home

│ │ │ │
│ │ │ │

Table of contents

│ │ │ │
    │ │ │ │
  • bdecode_node │ │ │ │ @@ -62,46 +62,46 @@ │ │ │ │ to be able to copy it as a reference for instance). For that, use the │ │ │ │ non_owning() member function.

    │ │ │ │

    There are 5 different types of nodes, see type_t.

    │ │ │ │ 
    │ │ │ │  struct bdecode_node
│ │ │ │  {
│ │ │ │     bdecode_node () = default;
│ │ │ │ -   bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │     bdecode_node (bdecode_node&&) noexcept;
│ │ │ │     bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +   bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │     bdecode_node (bdecode_node const&);
│ │ │ │     type_t type () const noexcept;
│ │ │ │     explicit operator bool () const noexcept;
│ │ │ │     bdecode_node non_owning () const;
│ │ │ │ -   std::ptrdiff_t data_offset () const noexcept;
│ │ │ │     span<char const> data_section () const noexcept;
│ │ │ │ +   std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ +   int list_size () const;
│ │ │ │ +   bdecode_node list_at (int i) const;
│ │ │ │     string_view list_string_value_at (int i
│ │ │ │        , string_view default_val = string_view()) const;
│ │ │ │     std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -   bdecode_node list_at (int i) const;
│ │ │ │ -   int list_size () const;
│ │ │ │ +   std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +   bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_dict (string_view key) const;
│ │ │ │     int dict_size () const;
│ │ │ │ +   bdecode_node dict_find (string_view key) const;
│ │ │ │     std::int64_t dict_find_int_value (string_view key
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -   bdecode_node dict_find (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_string (string_view key) const;
│ │ │ │     std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ -   bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -   std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │     string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │ -   bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_int (string_view key) const;
│ │ │ │     std::int64_t int_value () const;
│ │ │ │ -   int string_length () const;
│ │ │ │ +   std::ptrdiff_t string_offset () const;
│ │ │ │     char const* string_ptr () const;
│ │ │ │ +   int string_length () const;
│ │ │ │     string_view string_value () const;
│ │ │ │ -   std::ptrdiff_t string_offset () const;
│ │ │ │     void clear ();
│ │ │ │     void swap (bdecode_node& n);
│ │ │ │     void reserve (int tokens);
│ │ │ │     void switch_underlying_buffer (char const* buf) noexcept;
│ │ │ │     bool has_soft_error (span<char> error) const;
│ │ │ │  
│ │ │ │     enum type_t
│ │ │ │ @@ -116,22 +116,22 @@
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    bdecode_node()

    │ │ │ │ 
    │ │ │ │  bdecode_node () = default;
│ │ │ │
    │ │ │ │

    creates a default constructed node, it will have the type none_t.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    bdecode_node() operator=()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    operator=() bdecode_node()

    │ │ │ │ 
    │ │ │ │ -bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │  bdecode_node (bdecode_node&&) noexcept;
│ │ │ │  bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │  bdecode_node (bdecode_node const&);
│ │ │ │
    │ │ │ │

    For owning nodes, the copy will create a copy of the tree, but the │ │ │ │ underlying buffer remains the same.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    type()

    │ │ │ │ @@ -150,71 +150,71 @@ │ │ │ │
    │ │ │ │

    non_owning()

    │ │ │ │ 
    │ │ │ │  bdecode_node non_owning () const;
│ │ │ │
    │ │ │ │

    return a non-owning reference to this node. This is useful to refer to │ │ │ │ the root node without copying it in assignments.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    data_offset() data_section()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    data_section() data_offset()

    │ │ │ │ 
    │ │ │ │ -std::ptrdiff_t data_offset () const noexcept;
│ │ │ │  span<char const> data_section () const noexcept;
│ │ │ │ +std::ptrdiff_t data_offset () const noexcept;
│ │ │ │
    │ │ │ │

    returns the buffer and length of the section in the original bencoded │ │ │ │ buffer where this node is defined. For a dictionary for instance, this │ │ │ │ starts with d and ends with e, and has all the content of the │ │ │ │ dictionary in between. │ │ │ │ the data_offset() function returns the byte-offset to this node in, │ │ │ │ starting from the beginning of the buffer that was parsed.

    │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    list_at() list_size() list_int_value_at() list_string_value_at()

    │ │ │ │ + │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    list_int_value_at() list_size() list_at() list_string_value_at()

    │ │ │ │ 
    │ │ │ │ +int list_size () const;
│ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │  string_view list_string_value_at (int i
│ │ │ │        , string_view default_val = string_view()) const;
│ │ │ │  std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -bdecode_node list_at (int i) const;
│ │ │ │ -int list_size () const;
│ │ │ │
    │ │ │ │

    functions with the list_ prefix operate on lists. These functions are │ │ │ │ only valid if type() == list_t. list_at() returns the item │ │ │ │ in the list at index i. i may not be greater than or equal to the │ │ │ │ size of the list. size() returns the size of the list.

    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    dict_at_node() dict_find_int() dict_find_string() dict_find() dict_size() dict_find_list() dict_at() dict_find_string_value() dict_find_int_value() dict_find_dict()

    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    dict_at() dict_find_list() dict_find_string_value() dict_find() dict_find_int_value() dict_find_dict() dict_at_node() dict_size() dict_find_int() dict_find_string()

    │ │ │ │ 
    │ │ │ │ +std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +bdecode_node dict_find_dict (string_view key) const;
│ │ │ │  int dict_size () const;
│ │ │ │ +bdecode_node dict_find (string_view key) const;
│ │ │ │  std::int64_t dict_find_int_value (string_view key
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -bdecode_node dict_find (string_view key) const;
│ │ │ │ -bdecode_node dict_find_string (string_view key) const;
│ │ │ │  std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ -bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │  string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │ -bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +bdecode_node dict_find_int (string_view key) const;
│ │ │ │
    │ │ │ │

    Functions with the dict_ prefix operates on dictionaries. They are │ │ │ │ only valid if type() == dict_t. In case a key you're looking up │ │ │ │ contains a 0 byte, you cannot use the 0-terminated string overloads, │ │ │ │ but have to use string_view instead. dict_find_list will return a │ │ │ │ valid bdecode_node if the key is found _and_ it is a list. Otherwise │ │ │ │ it will return a default-constructed bdecode_node.

    │ │ │ │ @@ -229,25 +229,25 @@ │ │ │ │
    │ │ │ │

    int_value()

    │ │ │ │ 
    │ │ │ │  std::int64_t int_value () const;
│ │ │ │
    │ │ │ │

    this function is only valid if type() == int_t. It returns the │ │ │ │ value of the integer.

    │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    string_offset() string_length() string_value() string_ptr()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    string_ptr() string_value() string_offset() string_length()

    │ │ │ │ 
    │ │ │ │ -int string_length () const;
│ │ │ │ +std::ptrdiff_t string_offset () const;
│ │ │ │  char const* string_ptr () const;
│ │ │ │ +int string_length () const;
│ │ │ │  string_view string_value () const;
│ │ │ │ -std::ptrdiff_t string_offset () const;
│ │ │ │
    │ │ │ │

    these functions are only valid if type() == string_t. They return │ │ │ │ the string values. Note that string_ptr() is not 0-terminated. │ │ │ │ string_length() returns the number of bytes in the string. │ │ │ │ string_offset() returns the byte offset from the start of the parsed │ │ │ │ bencoded buffer this string can be found.

    │ │ │ │ [report issue]
    │ │ │ │ @@ -345,22 +345,22 @@ │ │ │ │

    print the bencoded structure in a human-readable format to a string │ │ │ │ that's returned.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    bdecode()

    │ │ │ │

    Declared in "libtorrent/bdecode.hpp"

    │ │ │ │ 
    │ │ │ │ +int bdecode (char const* start, char const* end, bdecode_node& ret
│ │ │ │ +   , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ │ +   , int token_limit = 2000000);
│ │ │ │  bdecode_node bdecode (span<char const> buffer
│ │ │ │     , int depth_limit = 100, int token_limit = 2000000);
│ │ │ │  bdecode_node bdecode (span<char const> buffer
│ │ │ │     , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ │     , int token_limit = 2000000);
│ │ │ │ -int bdecode (char const* start, char const* end, bdecode_node& ret
│ │ │ │ -   , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ │ -   , int token_limit = 2000000);
│ │ │ │
    │ │ │ │

    This function decodes/parses bdecoded data (for example a .torrent file). │ │ │ │ The data structure is returned in the ret argument. the buffer to parse │ │ │ │ is specified by the start of the buffer as well as the end, i.e. one │ │ │ │ byte past the end. If the buffer fails to parse, the function returns a │ │ │ │ non-zero value and fills in ec with the error code. The optional │ │ │ │ argument error_pos, if set to non-nullptr, will be set to the byte offset │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,25 +1,25 @@ │ │ │ │ │ > │ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_] │ │ │ │ │ VVeerrssiioonn:: 2.0.11 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _b_d_e_c_o_d_e___n_o_d_e │ │ │ │ │ o _b_d_e_c_o_d_e___n_o_d_e_(_) │ │ │ │ │ - o _b_d_e_c_o_d_e___n_o_d_e_(_)_ _o_p_e_r_a_t_o_r_=_(_) │ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _b_d_e_c_o_d_e___n_o_d_e_(_) │ │ │ │ │ o _t_y_p_e_(_) │ │ │ │ │ o _b_o_o_l_(_) │ │ │ │ │ o _n_o_n___o_w_n_i_n_g_(_) │ │ │ │ │ - o _d_a_t_a___o_f_f_s_e_t_(_)_ _d_a_t_a___s_e_c_t_i_o_n_(_) │ │ │ │ │ - o _l_i_s_t___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_) │ │ │ │ │ - o _d_i_c_t___a_t___n_o_d_e_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d_(_) │ │ │ │ │ - _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_) │ │ │ │ │ - _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_) │ │ │ │ │ + o _d_a_t_a___s_e_c_t_i_o_n_(_)_ _d_a_t_a___o_f_f_s_e_t_(_) │ │ │ │ │ + o _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_) │ │ │ │ │ + o _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d_(_) │ │ │ │ │ + _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___a_t___n_o_d_e_(_)_ _d_i_c_t___s_i_z_e_(_) │ │ │ │ │ + _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_) │ │ │ │ │ o _i_n_t___v_a_l_u_e_(_) │ │ │ │ │ - o _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___p_t_r_(_) │ │ │ │ │ + o _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _s_w_a_p_(_) │ │ │ │ │ o _r_e_s_e_r_v_e_(_) │ │ │ │ │ o _s_w_i_t_c_h___u_n_d_e_r_l_y_i_n_g___b_u_f_f_e_r_(_) │ │ │ │ │ o _h_a_s___s_o_f_t___e_r_r_o_r_(_) │ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t │ │ │ │ │ * _p_r_i_n_t___e_n_t_r_y_(_) │ │ │ │ │ @@ -30,46 +30,46 @@ │ │ │ │ │ Sometimes it's important to get a non-owning reference to the root node ( to be │ │ │ │ │ able to copy it as a reference for instance). For that, use the _n_o_n___o_w_n_i_n_g_(_) │ │ │ │ │ member function. │ │ │ │ │ There are 5 different types of nodes, see _t_y_p_e___t. │ │ │ │ │ struct bdecode_node │ │ │ │ │ { │ │ │ │ │ bbddeeccooddee__nnooddee () = default; │ │ │ │ │ - bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ + bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ type_t ttyyppee () const noexcept; │ │ │ │ │ explicit operator bbooooll () const noexcept; │ │ │ │ │ bdecode_node nnoonn__oowwnniinngg () const; │ │ │ │ │ - std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ span ddaattaa__sseeccttiioonn () const noexcept; │ │ │ │ │ + std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ + int lliisstt__ssiizzee () const; │ │ │ │ │ + bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i │ │ │ │ │ , string_view default_val = string_view()) const; │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ - bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ - int lliisstt__ssiizzee () const; │ │ │ │ │ + std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ int ddiicctt__ssiizzee () const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ - std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ std::int64_t iinntt__vvaalluuee () const; │ │ │ │ │ - int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ + std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ + int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ - std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ void cclleeaarr (); │ │ │ │ │ void sswwaapp (bdecode_node& n); │ │ │ │ │ void rreesseerrvvee (int tokens); │ │ │ │ │ void sswwiittcchh__uunnddeerrllyyiinngg__bbuuffffeerr (char const* buf) noexcept; │ │ │ │ │ bool hhaass__ssoofftt__eerrrroorr (span error) const; │ │ │ │ │ │ │ │ │ │ enum type_t │ │ │ │ │ @@ -82,18 +82,18 @@ │ │ │ │ │ }; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** bbddeeccooddee__nnooddee(()) ********** │ │ │ │ │ bbddeeccooddee__nnooddee () = default; │ │ │ │ │ creates a default constructed node, it will have the type none_t. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** bbddeeccooddee__nnooddee(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ -bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ +********** ooppeerraattoorr==(()) bbddeeccooddee__nnooddee(()) ********** │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ +bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ For owning nodes, the copy will create a copy of the tree, but the underlying │ │ │ │ │ buffer remains the same. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttyyppee(()) ********** │ │ │ │ │ type_t ttyyppee () const noexcept; │ │ │ │ │ the type of this node. See _t_y_p_e___t. │ │ │ │ │ @@ -103,50 +103,50 @@ │ │ │ │ │ returns true if _t_y_p_e_(_) != none_t. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnoonn__oowwnniinngg(()) ********** │ │ │ │ │ bdecode_node nnoonn__oowwnniinngg () const; │ │ │ │ │ return a non-owning reference to this node. This is useful to refer to the root │ │ │ │ │ node without copying it in assignments. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ddaattaa__ooffffsseett(()) ddaattaa__sseeccttiioonn(()) ********** │ │ │ │ │ -std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ +********** ddaattaa__sseeccttiioonn(()) ddaattaa__ooffffsseett(()) ********** │ │ │ │ │ span ddaattaa__sseeccttiioonn () const noexcept; │ │ │ │ │ +std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ returns the buffer and length of the section in the original bencoded buffer │ │ │ │ │ where this node is defined. For a dictionary for instance, this starts with d │ │ │ │ │ and ends with e, and has all the content of the dictionary in between. the │ │ │ │ │ data_offset() function returns the byte-offset to this node in, starting from │ │ │ │ │ the beginning of the buffer that was parsed. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** lliisstt__aatt(()) lliisstt__ssiizzee(()) lliisstt__iinntt__vvaalluuee__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) ********** │ │ │ │ │ +********** lliisstt__iinntt__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) ********** │ │ │ │ │ +int lliisstt__ssiizzee () const; │ │ │ │ │ +bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i │ │ │ │ │ , string_view default_val = string_view()) const; │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ -bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ -int lliisstt__ssiizzee () const; │ │ │ │ │ functions with the list_ prefix operate on lists. These functions are only │ │ │ │ │ valid if type() == list_t. list_at() returns the item in the list at index i. i │ │ │ │ │ may not be greater than or equal to the size of the list. size() returns the │ │ │ │ │ size of the list. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ddiicctt__aatt__nnooddee(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__ffiinndd(()) ddiicctt__ssiizzee(()) │ │ │ │ │ -ddiicctt__ffiinndd__lliisstt(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(()) │ │ │ │ │ -ddiicctt__ffiinndd__ddiicctt(()) ********** │ │ │ │ │ +********** ddiicctt__aatt(()) ddiicctt__ffiinndd__lliisstt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd(()) │ │ │ │ │ +ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__aatt__nnooddee(()) ddiicctt__ssiizzee(()) ddiicctt__ffiinndd__iinntt │ │ │ │ │ +(()) ddiicctt__ffiinndd__ssttrriinngg(()) ********** │ │ │ │ │ +std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ int ddiicctt__ssiizzee () const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ -std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ Functions with the dict_ prefix operates on dictionaries. They are only valid │ │ │ │ │ if type() == dict_t. In case a key you're looking up contains a 0 byte, you │ │ │ │ │ cannot use the 0-terminated string overloads, but have to use string_view │ │ │ │ │ instead. dict_find_list will return a valid bdecode_node if the key is found │ │ │ │ │ _and_ it is a list. Otherwise it will return a default-constructed │ │ │ │ │ _b_d_e_c_o_d_e___n_o_d_e. │ │ │ │ │ Functions with the _value suffix return the value of the node directly, rather │ │ │ │ │ @@ -158,19 +158,19 @@ │ │ │ │ │ string). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** iinntt__vvaalluuee(()) ********** │ │ │ │ │ std::int64_t iinntt__vvaalluuee () const; │ │ │ │ │ this function is only valid if type() == int_t. It returns the value of the │ │ │ │ │ integer. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ssttrriinngg__ooffffsseett(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__ppttrr(()) ********** │ │ │ │ │ -int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ +********** ssttrriinngg__ppttrr(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__ooffffsseett(()) ssttrriinngg__lleennggtthh(()) ********** │ │ │ │ │ +std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ +int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ -std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ these functions are only valid if type() == string_t. They return the string │ │ │ │ │ values. Note that string_ptr() is nnoott 0-terminated. string_length() returns the │ │ │ │ │ number of bytes in the string. string_offset() returns the byte offset from the │ │ │ │ │ start of the parsed bencoded buffer this string can be found. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** cclleeaarr(()) ********** │ │ │ │ │ void cclleeaarr (); │ │ │ │ │ @@ -214,22 +214,22 @@ │ │ │ │ │ std::string pprriinntt__eennttrryy (bdecode_node const& e │ │ │ │ │ , bool single_line = false, int indent = 0); │ │ │ │ │ print the bencoded structure in a human-readable format to a string that's │ │ │ │ │ returned. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ bbddeeccooddee(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_d_e_c_o_d_e_._h_p_p" │ │ │ │ │ +int bbddeeccooddee (char const* start, char const* end, bdecode_node& ret │ │ │ │ │ + , error_code& ec, int* error_pos = nullptr, int depth_limit = 100 │ │ │ │ │ + , int token_limit = 2000000); │ │ │ │ │ bdecode_node bbddeeccooddee (span buffer │ │ │ │ │ , int depth_limit = 100, int token_limit = 2000000); │ │ │ │ │ bdecode_node bbddeeccooddee (span buffer │ │ │ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100 │ │ │ │ │ , int token_limit = 2000000); │ │ │ │ │ -int bbddeeccooddee (char const* start, char const* end, bdecode_node& ret │ │ │ │ │ - , error_code& ec, int* error_pos = nullptr, int depth_limit = 100 │ │ │ │ │ - , int token_limit = 2000000); │ │ │ │ │ This function decodes/parses bdecoded data (for example a .torrent file). The │ │ │ │ │ data structure is returned in the ret argument. the buffer to parse is │ │ │ │ │ specified by the start of the buffer as well as the end, i.e. one byte past the │ │ │ │ │ end. If the buffer fails to parse, the function returns a non-zero value and │ │ │ │ │ fills in ec with the error code. The optional argument error_pos, if set to │ │ │ │ │ non-nullptr, will be set to the byte offset into the buffer where the parse │ │ │ │ │ failure occurred. │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Bencoding.html │ │ │ │ @@ -34,15 +34,15 @@ │ │ │ │

      │ │ │ │
    • entry │ │ │ │
      • │ │ │ │ @@ -69,44 +69,44 @@ │ │ │ │

      The entry class represents one node in a bencoded hierarchy. It works as a │ │ │ │ variant type, it can be either a list, a dictionary (std::map), an integer │ │ │ │ or a string.

      │ │ │ │ 
      │ │ │ │  class entry
│ │ │ │  {
│ │ │ │     data_type type () const;
│ │ │ │ -   entry (dictionary_type);
│ │ │ │ -   entry (span<char const>);
│ │ │ │ -   entry (preformatted_type);
│ │ │ │     entry (integer_type);
│ │ │ │ +   entry (span<char const>);
│ │ │ │     entry (list_type);
│ │ │ │ +   entry (dictionary_type);
│ │ │ │ +   entry (preformatted_type);
│ │ │ │     entry (U v);
│ │ │ │     entry (data_type t);
│ │ │ │     entry (bdecode_node const& n);
│ │ │ │ -   entry& operator= (preformatted_type) &;
│ │ │ │ -   entry& operator= (span<char const>) &;
│ │ │ │ -   entry& operator= (integer_type) &;
│ │ │ │     entry& operator= (bdecode_node const&) &;
│ │ │ │ -   entry& operator= (entry const&) &;
│ │ │ │     entry& operator= (dictionary_type) &;
│ │ │ │ -   entry& operator= (entry&&) & noexcept;
│ │ │ │ +   entry& operator= (entry const&) &;
│ │ │ │     entry& operator= (list_type) &;
│ │ │ │ +   entry& operator= (entry&&) & noexcept;
│ │ │ │ +   entry& operator= (integer_type) &;
│ │ │ │ +   entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (span<char const>) &;
│ │ │ │     entry& operator= (U v) &;
│ │ │ │ -   dictionary_type& dict ();
│ │ │ │ +   preformatted_type& preformatted ();
│ │ │ │ +   integer_type& integer ();
│ │ │ │ +   preformatted_type const& preformatted () const;
│ │ │ │     dictionary_type const& dict () const;
│ │ │ │ +   dictionary_type& dict ();
│ │ │ │ +   list_type const& list () const;
│ │ │ │     string_type& string ();
│ │ │ │ -   integer_type const& integer () const;
│ │ │ │     string_type const& string () const;
│ │ │ │ -   list_type const& list () const;
│ │ │ │ -   preformatted_type& preformatted ();
│ │ │ │     list_type& list ();
│ │ │ │ -   preformatted_type const& preformatted () const;
│ │ │ │ -   integer_type& integer ();
│ │ │ │ +   integer_type const& integer () const;
│ │ │ │     void swap (entry& e);
│ │ │ │ -   entry const& operator[] (string_view key) const;
│ │ │ │     entry& operator[] (string_view key);
│ │ │ │ +   entry const& operator[] (string_view key) const;
│ │ │ │     entry* find_key (string_view key);
│ │ │ │     entry const* find_key (string_view key) const;
│ │ │ │     std::string to_string (bool single_line = false) const;
│ │ │ │  
│ │ │ │     enum data_type
│ │ │ │     {
│ │ │ │        int_t,
│ │ │ │ @@ -124,19 +124,19 @@
│ │ │ │  data_type type () const;
│ │ │ │
      │ │ │ │

      returns the concrete type of the entry

      │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    entry()

    │ │ │ │ 
    │ │ │ │ -entry (dictionary_type);
│ │ │ │ -entry (span<char const>);
│ │ │ │ -entry (preformatted_type);
│ │ │ │  entry (integer_type);
│ │ │ │ +entry (span<char const>);
│ │ │ │  entry (list_type);
│ │ │ │ +entry (dictionary_type);
│ │ │ │ +entry (preformatted_type);
│ │ │ │
    │ │ │ │

    constructors directly from a specific type. │ │ │ │ The content of the argument is copied into the │ │ │ │ newly constructed entry

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    entry()

    │ │ │ │ @@ -152,43 +152,43 @@ │ │ │ │ entry (bdecode_node const& n); │ │ │ │ │ │ │ │

    construct from bdecode_node parsed form (see bdecode())

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    operator=()

    │ │ │ │ 
    │ │ │ │ -entry& operator= (preformatted_type) &;
│ │ │ │ -entry& operator= (span<char const>) &;
│ │ │ │ -entry& operator= (integer_type) &;
│ │ │ │  entry& operator= (bdecode_node const&) &;
│ │ │ │ -entry& operator= (entry const&) &;
│ │ │ │  entry& operator= (dictionary_type) &;
│ │ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ │ +entry& operator= (entry const&) &;
│ │ │ │  entry& operator= (list_type) &;
│ │ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ │ +entry& operator= (integer_type) &;
│ │ │ │ +entry& operator= (preformatted_type) &;
│ │ │ │ +entry& operator= (span<char const>) &;
│ │ │ │
    │ │ │ │

    copies the structure of the right hand side into this │ │ │ │ entry.

    │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    preformatted() string() integer() dict() list()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    integer() list() dict() string() preformatted()

    │ │ │ │ 
    │ │ │ │ -dictionary_type& dict ();
│ │ │ │ +preformatted_type& preformatted ();
│ │ │ │ +integer_type& integer ();
│ │ │ │ +preformatted_type const& preformatted () const;
│ │ │ │  dictionary_type const& dict () const;
│ │ │ │ +dictionary_type& dict ();
│ │ │ │ +list_type const& list () const;
│ │ │ │  string_type& string ();
│ │ │ │ -integer_type const& integer () const;
│ │ │ │  string_type const& string () const;
│ │ │ │ -list_type const& list () const;
│ │ │ │ -preformatted_type& preformatted ();
│ │ │ │  list_type& list ();
│ │ │ │ -preformatted_type const& preformatted () const;
│ │ │ │ -integer_type& integer ();
│ │ │ │ +integer_type const& integer () const;
│ │ │ │
    │ │ │ │

    The integer(), string(), list() and dict() functions │ │ │ │ are accessors that return the respective type. If the entry object │ │ │ │ isn't of the type you request, the accessor will throw │ │ │ │ system_error. You can ask an entry for its type through the │ │ │ │ type() function.

    │ │ │ │

    If you want to create an entry you give it the type you want it to │ │ │ │ @@ -232,16 +232,16 @@ │ │ │ │ void swap (entry& e); │ │ │ │ │ │ │ │

    swaps the content of this with e.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    operator[]()

    │ │ │ │ 
    │ │ │ │ -entry const& operator[] (string_view key) const;
│ │ │ │  entry& operator[] (string_view key);
│ │ │ │ +entry const& operator[] (string_view key) const;
│ │ │ │
    │ │ │ │

    All of these functions requires the entry to be a dictionary, if it │ │ │ │ isn't they will throw system_error.

    │ │ │ │

    The non-const versions of the operator[] will return a reference │ │ │ │ to either the existing element at the given key or, if there is no │ │ │ │ element with the given key, a reference to a newly inserted element at │ │ │ │ that key.

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -5,15 +5,15 @@ │ │ │ │ │ Table of contents │ │ │ │ │ * _e_n_t_r_y │ │ │ │ │ o _t_y_p_e_(_) │ │ │ │ │ o _e_n_t_r_y_(_) │ │ │ │ │ o _e_n_t_r_y_(_) │ │ │ │ │ o _e_n_t_r_y_(_) │ │ │ │ │ o _o_p_e_r_a_t_o_r_=_(_) │ │ │ │ │ - o _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)_ _i_n_t_e_g_e_r_(_)_ _d_i_c_t_(_)_ _l_i_s_t_(_) │ │ │ │ │ + o _i_n_t_e_g_e_r_(_)_ _l_i_s_t_(_)_ _d_i_c_t_(_)_ _s_t_r_i_n_g_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_) │ │ │ │ │ o _s_w_a_p_(_) │ │ │ │ │ o _o_p_e_r_a_t_o_r_[_]_(_) │ │ │ │ │ o _f_i_n_d___k_e_y_(_) │ │ │ │ │ o _t_o___s_t_r_i_n_g_(_) │ │ │ │ │ o _e_n_u_m_ _d_a_t_a___t_y_p_e │ │ │ │ │ * _o_p_e_r_a_t_o_r_<_<_(_) │ │ │ │ │ * _b_e_n_c_o_d_e_(_) │ │ │ │ │ @@ -35,44 +35,44 @@ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_n_t_r_y_._h_p_p" │ │ │ │ │ The entry class represents one node in a bencoded hierarchy. It works as a │ │ │ │ │ variant type, it can be either a list, a dictionary (std::map), an integer or a │ │ │ │ │ string. │ │ │ │ │ class entry │ │ │ │ │ { │ │ │ │ │ data_type ttyyppee () const; │ │ │ │ │ - eennttrryy (dictionary_type); │ │ │ │ │ - eennttrryy (span); │ │ │ │ │ - eennttrryy (preformatted_type); │ │ │ │ │ eennttrryy (integer_type); │ │ │ │ │ + eennttrryy (span); │ │ │ │ │ eennttrryy (list_type); │ │ │ │ │ + eennttrryy (dictionary_type); │ │ │ │ │ + eennttrryy (preformatted_type); │ │ │ │ │ eennttrryy (U v); │ │ │ │ │ eennttrryy (data_type t); │ │ │ │ │ eennttrryy (bdecode_node const& n); │ │ │ │ │ - entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (span) &; │ │ │ │ │ - entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ - entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ + entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ + entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (U v) &; │ │ │ │ │ - dictionary_type& ddiicctt (); │ │ │ │ │ + preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ + integer_type& iinntteeggeerr (); │ │ │ │ │ + preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ dictionary_type const& ddiicctt () const; │ │ │ │ │ + dictionary_type& ddiicctt (); │ │ │ │ │ + list_type const& lliisstt () const; │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ - integer_type const& iinntteeggeerr () const; │ │ │ │ │ string_type const& ssttrriinngg () const; │ │ │ │ │ - list_type const& lliisstt () const; │ │ │ │ │ - preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ list_type& lliisstt (); │ │ │ │ │ - preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ - integer_type& iinntteeggeerr (); │ │ │ │ │ + integer_type const& iinntteeggeerr () const; │ │ │ │ │ void sswwaapp (entry& e); │ │ │ │ │ - entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key); │ │ │ │ │ + entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ entry const* ffiinndd__kkeeyy (string_view key) const; │ │ │ │ │ std::string ttoo__ssttrriinngg (bool single_line = false) const; │ │ │ │ │ │ │ │ │ │ enum data_type │ │ │ │ │ { │ │ │ │ │ int_t, │ │ │ │ │ @@ -85,52 +85,52 @@ │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttyyppee(()) ********** │ │ │ │ │ data_type ttyyppee () const; │ │ │ │ │ returns the concrete type of the _e_n_t_r_y │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennttrryy(()) ********** │ │ │ │ │ -eennttrryy (dictionary_type); │ │ │ │ │ -eennttrryy (span); │ │ │ │ │ -eennttrryy (preformatted_type); │ │ │ │ │ eennttrryy (integer_type); │ │ │ │ │ +eennttrryy (span); │ │ │ │ │ eennttrryy (list_type); │ │ │ │ │ +eennttrryy (dictionary_type); │ │ │ │ │ +eennttrryy (preformatted_type); │ │ │ │ │ constructors directly from a specific type. The content of the argument is │ │ │ │ │ copied into the newly constructed _e_n_t_r_y │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennttrryy(()) ********** │ │ │ │ │ eennttrryy (data_type t); │ │ │ │ │ construct an empty _e_n_t_r_y of the specified type. see _d_a_t_a___t_y_p_e enum. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennttrryy(()) ********** │ │ │ │ │ eennttrryy (bdecode_node const& n); │ │ │ │ │ construct from _b_d_e_c_o_d_e___n_o_d_e parsed form (see _b_d_e_c_o_d_e_(_)) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ooppeerraattoorr==(()) ********** │ │ │ │ │ -entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (span) &; │ │ │ │ │ -entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ -entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ +entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ +entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (span) &; │ │ │ │ │ copies the structure of the right hand side into this _e_n_t_r_y. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) iinntteeggeerr(()) ddiicctt(()) lliisstt(()) ********** │ │ │ │ │ -dictionary_type& ddiicctt (); │ │ │ │ │ +********** iinntteeggeerr(()) lliisstt(()) ddiicctt(()) ssttrriinngg(()) pprreeffoorrmmaatttteedd(()) ********** │ │ │ │ │ +preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ +integer_type& iinntteeggeerr (); │ │ │ │ │ +preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ dictionary_type const& ddiicctt () const; │ │ │ │ │ +dictionary_type& ddiicctt (); │ │ │ │ │ +list_type const& lliisstt () const; │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ -integer_type const& iinntteeggeerr () const; │ │ │ │ │ string_type const& ssttrriinngg () const; │ │ │ │ │ -list_type const& lliisstt () const; │ │ │ │ │ -preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ list_type& lliisstt (); │ │ │ │ │ -preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ -integer_type& iinntteeggeerr (); │ │ │ │ │ +integer_type const& iinntteeggeerr () const; │ │ │ │ │ The integer(), string(), list() and dict() functions are accessors that return │ │ │ │ │ the respective type. If the entry object isn't of the type you request, the │ │ │ │ │ accessor will throw system_error. You can ask an entry for its type through the │ │ │ │ │ type() function. │ │ │ │ │ If you want to create an entry you give it the type you want it to have in its │ │ │ │ │ constructor, and then use one of the non-const accessors to get a reference │ │ │ │ │ which you then can assign the value you want it to have. │ │ │ │ │ @@ -161,16 +161,16 @@ │ │ │ │ │ _t_o_r_r_e_n_t___i_n_f_o exists. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sswwaapp(()) ********** │ │ │ │ │ void sswwaapp (entry& e); │ │ │ │ │ swaps the content of tthhiiss with e. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ooppeerraattoorr[[]](()) ********** │ │ │ │ │ -entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key); │ │ │ │ │ +entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ All of these functions requires the _e_n_t_r_y to be a dictionary, if it isn't they │ │ │ │ │ will throw system_error. │ │ │ │ │ The non-const versions of the operator[] will return a reference to either the │ │ │ │ │ existing element at the given key or, if there is no element with the given │ │ │ │ │ key, a reference to a newly inserted element at that key. │ │ │ │ │ The const version of operator[] will only return a reference to an existing │ │ │ │ │ element at the given key. If the key is not found, it will throw system_error. │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Core.html │ │ │ │ @@ -34,15 +34,15 @@ │ │ │ │
    │ │ │ │ 
    │ │ │ │  struct info_hash_t
│ │ │ │  {
│ │ │ │ -   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ +   info_hash_t () noexcept = default;
│ │ │ │     info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ +   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │     explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ -   info_hash_t () noexcept = default;
│ │ │ │     bool has (protocol_version v) const;
│ │ │ │     bool has_v1 () const;
│ │ │ │     bool has_v2 () const;
│ │ │ │     sha1_hash get (protocol_version v) const;
│ │ │ │     sha1_hash get_best () const;
│ │ │ │     friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │     friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept;
│ │ │ │ @@ -587,29 +587,29 @@
│ │ │ │     sha1_hash v1;
│ │ │ │     sha256_hash v2;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    info_hash_t()

    │ │ │ │ 
    │ │ │ │ -explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ +info_hash_t () noexcept = default;
│ │ │ │  info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ +explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │  explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ -info_hash_t () noexcept = default;
│ │ │ │
    │ │ │ │

    The default constructor creates an object that has neither a v1 or v2 │ │ │ │ hash.

    │ │ │ │

    For backwards compatibility, make it possible to construct directly │ │ │ │ from a v1 hash. This constructor allows implicit conversion from a │ │ │ │ v1 hash, but the implicitness is deprecated.

    │ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    has_v2() has_v1() has()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    has_v1() has_v2() has()

    │ │ │ │ 
    │ │ │ │  bool has (protocol_version v) const;
│ │ │ │  bool has_v1 () const;
│ │ │ │  bool has_v2 () const;
│ │ │ │
    │ │ │ │

    returns true if the corresponding info hash is present in this │ │ │ │ object.

    │ │ │ │ @@ -643,16 +643,16 @@ │ │ │ │
    │ │ │ │
    │ │ │ │

    piece_block

    │ │ │ │

    Declared in "libtorrent/piece_block.hpp"

    │ │ │ │ 
    │ │ │ │  struct piece_block
│ │ │ │  {
│ │ │ │ -   piece_block () = default;
│ │ │ │     piece_block (piece_index_t p_index, int b_index);
│ │ │ │ +   piece_block () = default;
│ │ │ │     bool operator< (piece_block const& b) const;
│ │ │ │     bool operator== (piece_block const& b) const;
│ │ │ │     bool operator!= (piece_block const& b) const;
│ │ │ │  
│ │ │ │     static const piece_block invalid;
│ │ │ │     piece_index_t piece_index {0};
│ │ │ │     int block_index  = 0;
│ │ │ │ @@ -697,26 +697,26 @@
│ │ │ │  
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │
    │ │ │ │

    load_torrent_parsed() load_torrent_buffer() load_torrent_file()

    │ │ │ │

    Declared in "libtorrent/load_torrent.hpp"

    │ │ │ │ 
    │ │ │ │ +add_torrent_params load_torrent_buffer (
│ │ │ │ +   span<char const> buffer);
│ │ │ │  add_torrent_params load_torrent_file (
│ │ │ │     std::string const& filename);
│ │ │ │  add_torrent_params load_torrent_parsed (
│ │ │ │ +   bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +add_torrent_params load_torrent_parsed (
│ │ │ │     bdecode_node const& torrent_file);
│ │ │ │ -add_torrent_params load_torrent_file (
│ │ │ │ -   std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │  add_torrent_params load_torrent_buffer (
│ │ │ │     span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_parsed (
│ │ │ │ -   bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_buffer (
│ │ │ │ -   span<char const> buffer);
│ │ │ │ +add_torrent_params load_torrent_file (
│ │ │ │ +   std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │
    │ │ │ │

    These functions load the content of a .torrent file into an │ │ │ │ add_torrent_params object. │ │ │ │ The immutable part of a torrent file (the info-dictionary) is stored in │ │ │ │ the ti field in the add_torrent_params object (as a torrent_info │ │ │ │ object). │ │ │ │ The returned object is suitable to be:

    │ │ │ │ @@ -728,17 +728,17 @@ │ │ │ │
│ │ │ │ │ │ │ │ [report issue]
│ │ │ │
│ │ │ │

make_magnet_uri()

│ │ │ │

Declared in "libtorrent/magnet_uri.hpp"

│ │ │ │ 
│ │ │ │ -std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │ -std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │  std::string make_magnet_uri (torrent_info const& info);
│ │ │ │ +std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │ +std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │
│ │ │ │

Generates a magnet URI from the specified torrent.

│ │ │ │

Several fields from the add_torrent_params objects are recorded in the │ │ │ │ magnet link. In order to not include them, they have to be cleared before │ │ │ │ calling make_magnet_uri(). These fields are used:

│ │ │ │
│ │ │ │ ti, info_hashes, url_seeds, dht_nodes, │ │ │ │ @@ -758,16 +758,16 @@ │ │ │ │ an empty string is returned.

│ │ │ │

For more information about magnet links, see magnet links.

│ │ │ │ [report issue]
│ │ │ │
│ │ │ │

parse_magnet_uri()

│ │ │ │

Declared in "libtorrent/magnet_uri.hpp"

│ │ │ │ 
│ │ │ │ -add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │  void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ +add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │  add_torrent_params parse_magnet_uri (string_view uri, error_code& ec);
│ │ │ │
│ │ │ │

This function parses out information from the magnet link and populates the │ │ │ │ add_torrent_params object. The overload that does not take an │ │ │ │ error_code reference will throw a system_error on error │ │ │ │ The overload taking an add_torrent_params reference will fill in the │ │ │ │ fields specified in the magnet URI.

│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -3,15 +3,15 @@ │ │ │ │ │ VVeerrssiioonn:: 2.0.11 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _p_e_e_r___i_n_f_o │ │ │ │ │ o _i_2_p___d_e_s_t_i_n_a_t_i_o_n_(_) │ │ │ │ │ * _i_n_f_o___h_a_s_h___t │ │ │ │ │ o _i_n_f_o___h_a_s_h___t_(_) │ │ │ │ │ - o _h_a_s___v_2_(_)_ _h_a_s___v_1_(_)_ _h_a_s_(_) │ │ │ │ │ + o _h_a_s___v_1_(_)_ _h_a_s___v_2_(_)_ _h_a_s_(_) │ │ │ │ │ o _g_e_t_(_) │ │ │ │ │ o _g_e_t___b_e_s_t_(_) │ │ │ │ │ o _f_o_r___e_a_c_h_(_) │ │ │ │ │ * _p_i_e_c_e___b_l_o_c_k │ │ │ │ │ * _p_e_e_r___r_e_q_u_e_s_t │ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_) │ │ │ │ │ * _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)_ _l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)_ _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_) │ │ │ │ │ @@ -413,18 +413,18 @@ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p" │ │ │ │ │ class holding the info-hash of a torrent. It can hold a v1 info-hash (SHA-1) or │ │ │ │ │ a v2 info-hash (SHA-256) or both. │ │ │ │ │ Note │ │ │ │ │ If has_v2() is false then the v1 hash might actually be a truncated v2 hash │ │ │ │ │ struct info_hash_t │ │ │ │ │ { │ │ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ + iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ - iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ bool hhaass (protocol_version v) const; │ │ │ │ │ bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass__vv22 () const; │ │ │ │ │ sha1_hash ggeett (protocol_version v) const; │ │ │ │ │ sha1_hash ggeett__bbeesstt () const; │ │ │ │ │ friend bool ooppeerraattoorr!!== (info_hash_t const& lhs, info_hash_t const& rhs); │ │ │ │ │ friend bool ooppeerraattoorr==== (info_hash_t const& lhs, info_hash_t const& rhs) │ │ │ │ │ @@ -434,24 +434,24 @@ │ │ │ │ │ friend std::ostream& ooppeerraattoorr<<<< (std::ostream& os, info_hash_t const& ih); │ │ │ │ │ │ │ │ │ │ sha1_hash v1; │ │ │ │ │ sha256_hash v2; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** iinnffoo__hhaasshh__tt(()) ********** │ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ +iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ -iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ The default constructor creates an object that has neither a v1 or v2 hash. │ │ │ │ │ For backwards compatibility, make it possible to construct directly from a v1 │ │ │ │ │ hash. This constructor allows iimmpplliicciitt conversion from a v1 hash, but the │ │ │ │ │ implicitness is deprecated. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** hhaass__vv22(()) hhaass__vv11(()) hhaass(()) ********** │ │ │ │ │ +********** hhaass__vv11(()) hhaass__vv22(()) hhaass(()) ********** │ │ │ │ │ bool hhaass (protocol_version v) const; │ │ │ │ │ bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass__vv22 () const; │ │ │ │ │ returns true if the corresponding info hash is present in this object. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ggeett(()) ********** │ │ │ │ │ sha1_hash ggeett (protocol_version v) const; │ │ │ │ │ @@ -468,16 +468,16 @@ │ │ │ │ │ The signature of F is: │ │ │ │ │ void(sha1_hash const&, protocol_version); │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ppiieeccee__bblloocckk ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_i_e_c_e___b_l_o_c_k_._h_p_p" │ │ │ │ │ struct piece_block │ │ │ │ │ { │ │ │ │ │ - ppiieeccee__bblloocckk () = default; │ │ │ │ │ ppiieeccee__bblloocckk (piece_index_t p_index, int b_index); │ │ │ │ │ + ppiieeccee__bblloocckk () = default; │ │ │ │ │ bool ooppeerraattoorr<< (piece_block const& b) const; │ │ │ │ │ bool ooppeerraattoorr==== (piece_block const& b) const; │ │ │ │ │ bool ooppeerraattoorr!!== (piece_block const& b) const; │ │ │ │ │ │ │ │ │ │ static const piece_block invalid; │ │ │ │ │ piece_index_t piece_index {0}; │ │ │ │ │ int bblloocckk__iinnddeexx = 0; │ │ │ │ │ @@ -508,39 +508,39 @@ │ │ │ │ │ The byte offset within that piece where the range starts. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ length │ │ │ │ │ The size of the range, in bytes. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ffiillee(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_l_o_a_d___t_o_r_r_e_n_t_._h_p_p" │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ + span buffer); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ std::string const& filename); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ bdecode_node const& torrent_file); │ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ - std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ span buffer, load_torrent_limits const& cfg); │ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ - bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ - span buffer); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ + std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s │ │ │ │ │ object. The immutable part of a torrent file (the info-dictionary) is stored in │ │ │ │ │ the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The │ │ │ │ │ returned object is suitable to be: │ │ │ │ │ * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) │ │ │ │ │ * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ mmaakkee__mmaaggnneett__uurrii(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p" │ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle); │ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp); │ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info); │ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp); │ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle); │ │ │ │ │ Generates a magnet URI from the specified torrent. │ │ │ │ │ Several fields from the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s objects are recorded in the magnet │ │ │ │ │ link. In order to not include them, they have to be cleared before calling │ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_). These fields are used: │ │ │ │ │ ti, info_hashes, url_seeds, dht_nodes, file_priorities, trackers, │ │ │ │ │ name, peers. │ │ │ │ │ Depending on what the use case for the resulting magnet link is, clearing peers │ │ │ │ │ @@ -555,16 +555,16 @@ │ │ │ │ │ The overload that takes a _t_o_r_r_e_n_t___h_a_n_d_l_e will make blocking calls to query │ │ │ │ │ information about the torrent. If the torrent handle is invalid, an empty │ │ │ │ │ string is returned. │ │ │ │ │ For more information about magnet links, see _m_a_g_n_e_t_ _l_i_n_k_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ppaarrssee__mmaaggnneett__uurrii(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p" │ │ │ │ │ -add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri); │ │ │ │ │ void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec); │ │ │ │ │ +add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri); │ │ │ │ │ add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec); │ │ │ │ │ This function parses out information from the magnet link and populates the │ │ │ │ │ _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object. The overload that does not take an error_code │ │ │ │ │ reference will throw a system_error on error The overload taking an │ │ │ │ │ add_torrent_params reference will fill in the fields specified in the magnet │ │ │ │ │ URI. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Create_Torrents.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -116,34 +116,34 @@ │ │ │ │ entry generate () const; │ │ │ │ file_storage const& files () const; │ │ │ │ void set_comment (char const* str); │ │ │ │ void set_creator (char const* str); │ │ │ │ void set_creation_date (std::time_t timestamp); │ │ │ │ void set_hash (piece_index_t index, sha1_hash const& h); │ │ │ │ void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h); │ │ │ │ - void add_url_seed (string_view url); │ │ │ │ void add_http_seed (string_view url); │ │ │ │ + void add_url_seed (string_view url); │ │ │ │ void add_node (std::pair<std::string, int> node); │ │ │ │ void add_tracker (string_view url, int tier = 0); │ │ │ │ void set_root_cert (string_view cert); │ │ │ │ void set_priv (bool p); │ │ │ │ bool priv () const; │ │ │ │ - bool is_v2_only () const; │ │ │ │ bool is_v1_only () const; │ │ │ │ + bool is_v2_only () const; │ │ │ │ int num_pieces () const; │ │ │ │ piece_index_t end_piece () const; │ │ │ │ index_range<piece_index_t> piece_range () const noexcept; │ │ │ │ file_index_t end_file () const; │ │ │ │ index_range<file_index_t> file_range () const noexcept; │ │ │ │ index_range<piece_index_t::diff_type> file_piece_range (file_index_t f); │ │ │ │ std::int64_t total_size () const; │ │ │ │ int piece_size (piece_index_t i) const; │ │ │ │ int piece_length () const; │ │ │ │ - void add_collection (string_view c); │ │ │ │ void add_similar_torrent (sha1_hash ih); │ │ │ │ + void add_collection (string_view c); │ │ │ │ │ │ │ │ static constexpr create_flags_t modification_time = 2_bit; │ │ │ │ static constexpr create_flags_t symlinks = 3_bit; │ │ │ │ static constexpr create_flags_t v2_only = 5_bit; │ │ │ │ static constexpr create_flags_t v1_only = 6_bit; │ │ │ │ static constexpr create_flags_t canonical_files = 7_bit; │ │ │ │ static constexpr create_flags_t no_attributes = 8_bit; │ │ │ │ @@ -277,16 +277,16 @@ │ │ │ │ This function will throw std::system_error if it is called on an │ │ │ │ object constructed with the v1_only flag.

│ │ │ │ │ │ │ │ [report issue]
│ │ │ │
│ │ │ │

add_http_seed() add_url_seed()

│ │ │ │ 
│ │ │ │ -void add_url_seed (string_view url);
│ │ │ │  void add_http_seed (string_view url);
│ │ │ │ +void add_url_seed (string_view url);
│ │ │ │
│ │ │ │

This adds a url seed to the torrent. You can have any number of url seeds. For a │ │ │ │ single file torrent, this should be an HTTP url, pointing to a file with identical │ │ │ │ content as the file of the torrent. For a multi-file torrent, it should point to │ │ │ │ a directory containing a directory with the same name as this torrent, and all the │ │ │ │ files of the torrent in it.

│ │ │ │

The second function, add_http_seed() adds an HTTP seed instead.

│ │ │ │ @@ -385,16 +385,16 @@ │ │ │ │ last one. piece_size() returns the size of the specified piece. │ │ │ │ these functions are just forwarding to the associated file_storage.

│ │ │ │ │ │ │ │ [report issue]
│ │ │ │
│ │ │ │

add_similar_torrent() add_collection()

│ │ │ │ 
│ │ │ │ -void add_collection (string_view c);
│ │ │ │  void add_similar_torrent (sha1_hash ih);
│ │ │ │ +void add_collection (string_view c);
│ │ │ │
│ │ │ │

Add similar torrents (by info-hash) or collections of similar torrents. │ │ │ │ Similar torrents are expected to share some files with this torrent. │ │ │ │ Torrents sharing a collection name with this torrent are also expected │ │ │ │ to share files with this torrent. A torrent may have more than one │ │ │ │ collection and more than one similar torrents. For more information, │ │ │ │ see BEP 38.

│ │ │ │ @@ -459,17 +459,17 @@ │ │ │ │ [report issue]
│ │ │ │
│ │ │ │
│ │ │ │

add_files()

│ │ │ │

Declared in "libtorrent/create_torrent.hpp"

│ │ │ │ 
│ │ │ │  void add_files (file_storage& fs, std::string const& file
│ │ │ │ -   , create_flags_t flags = {});
│ │ │ │ -void add_files (file_storage& fs, std::string const& file
│ │ │ │     , std::function<bool(std::string)> p, create_flags_t flags = {});
│ │ │ │ +void add_files (file_storage& fs, std::string const& file
│ │ │ │ +   , create_flags_t flags = {});
│ │ │ │
│ │ │ │

Adds the file specified by path to the file_storage object. In case path │ │ │ │ refers to a directory, files will be added recursively from the directory.

│ │ │ │

If specified, the predicate p is called once for every file and directory that │ │ │ │ is encountered. Files for which p returns true are added, and directories for │ │ │ │ which p returns true are traversed. p must have the following signature:

│ │ │ │ 
│ │ │ │ @@ -483,28 +483,28 @@
│ │ │ │  constructor.

│ │ │ │  [report issue]
│ │ │ │
│ │ │ │

set_piece_hashes()

│ │ │ │

Declared in "libtorrent/create_torrent.hpp"

│ │ │ │ 
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ -   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ -void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │     , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │  inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │  inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │     , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , std::function<void(piece_index_t)> const& f);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ +   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │     , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , std::function<void(piece_index_t)> const& f);
│ │ │ │
│ │ │ │

This function will assume that the files added to the torrent file exists at path │ │ │ │ p, read those files and hash the content and set the hashes in the create_torrent │ │ │ │ object. The optional function f is called in between every hash that is set. f │ │ │ │ must have the following signature:

│ │ │ │ 
│ │ │ │  void Fun(piece_index_t);
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -78,34 +78,34 @@
│ │ │ │ │     file_storage const& ffiilleess () const;
│ │ │ │ │     void sseett__ccoommmmeenntt (char const* str);
│ │ │ │ │     void sseett__ccrreeaattoorr (char const* str);
│ │ │ │ │     void sseett__ccrreeaattiioonn__ddaattee (std::time_t timestamp);
│ │ │ │ │     void sseett__hhaasshh (piece_index_t index, sha1_hash const& h);
│ │ │ │ │     void sseett__hhaasshh22 (file_index_t file, piece_index_t::diff_type piece,
│ │ │ │ │  sha256_hash const& h);
│ │ │ │ │ -   void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │     void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ +   void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │     void aadddd__nnooddee (std::pair node);
│ │ │ │ │     void aadddd__ttrraacckkeerr (string_view url, int tier = 0);
│ │ │ │ │     void sseett__rroooott__cceerrtt (string_view cert);
│ │ │ │ │     void sseett__pprriivv (bool p);
│ │ │ │ │     bool pprriivv () const;
│ │ │ │ │ -   bool iiss__vv22__oonnllyy () const;
│ │ │ │ │     bool iiss__vv11__oonnllyy () const;
│ │ │ │ │ +   bool iiss__vv22__oonnllyy () const;
│ │ │ │ │     int nnuumm__ppiieecceess () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │     file_index_t eenndd__ffiillee () const;
│ │ │ │ │     index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │     index_range ffiillee__ppiieeccee__rraannggee (file_index_t f);
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │     int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │     int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ -   void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │     void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │ +   void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │  
│ │ │ │ │     static constexpr create_flags_t mmooddiiffiiccaattiioonn__ttiimmee  = 2_bit;
│ │ │ │ │     static constexpr create_flags_t ssyymmlliinnkkss  = 3_bit;
│ │ │ │ │     static constexpr create_flags_t vv22__oonnllyy  = 5_bit;
│ │ │ │ │     static constexpr create_flags_t vv11__oonnllyy  = 6_bit;
│ │ │ │ │     static constexpr create_flags_t ccaannoonniiccaall__ffiilleess  = 7_bit;
│ │ │ │ │     static constexpr create_flags_t nnoo__aattttrriibbuutteess  = 8_bit;
│ │ │ │ │ @@ -199,16 +199,16 @@
│ │ │ │ │  be powers-of-2, so all per-piece merkle trees are complete. A SHA-256 hash of
│ │ │ │ │  all zeros is internally used to indicate a hash that has not been set. Setting
│ │ │ │ │  such hash will not be considered set when calling _g_e_n_e_r_a_t_e_(_). This function
│ │ │ │ │  will throw std::system_error if it is called on an object constructed with the
│ │ │ │ │  v1_only flag.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │  void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ +void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │  This adds a url seed to the torrent. You can have any number of url seeds. For
│ │ │ │ │  a single file torrent, this should be an HTTP url, pointing to a file with
│ │ │ │ │  identical content as the file of the torrent. For a multi-file torrent, it
│ │ │ │ │  should point to a directory containing a directory with the same name as this
│ │ │ │ │  torrent, and all the files of the torrent in it.
│ │ │ │ │  The second function, add_http_seed() adds an HTTP seed instead.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -271,16 +271,16 @@
│ │ │ │ │  int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │  int ppiieeccee__lleennggtthh () const;
│ │ │ │ │  piece_length() returns the piece size of all pieces but the last one.
│ │ │ │ │  piece_size() returns the size of the specified piece. these functions are just
│ │ │ │ │  forwarding to the associated _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) **********
│ │ │ │ │ -void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │  void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │ +void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │  Add similar torrents (by info-hash) or collections of similar torrents. Similar
│ │ │ │ │  torrents are expected to share some files with this torrent. Torrents sharing a
│ │ │ │ │  collection name with this torrent are also expected to share files with this
│ │ │ │ │  torrent. A torrent may have more than one collection and more than one similar
│ │ │ │ │  torrents. For more information, see _B_E_P_ _3_8.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    modification_time
│ │ │ │ │ @@ -330,17 +330,17 @@
│ │ │ │ │        behavior deviates from the specification but was the way libtorrent
│ │ │ │ │        created torrents in version up to and including 2.0.7. This flag is here
│ │ │ │ │        for backwards compatibility.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ aadddd__ffiilleess(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_r_e_a_t_e___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │  void aadddd__ffiilleess (file_storage& fs, std::string const& file
│ │ │ │ │ -   , create_flags_t flags = {});
│ │ │ │ │ -void aadddd__ffiilleess (file_storage& fs, std::string const& file
│ │ │ │ │     , std::function p, create_flags_t flags = {});
│ │ │ │ │ +void aadddd__ffiilleess (file_storage& fs, std::string const& file
│ │ │ │ │ +   , create_flags_t flags = {});
│ │ │ │ │  Adds the file specified by path to the _f_i_l_e___s_t_o_r_a_g_e object. In case path refers
│ │ │ │ │  to a directory, files will be added recursively from the directory.
│ │ │ │ │  If specified, the predicate p is called once for every file and directory that
│ │ │ │ │  is encountered. Files for which p returns true are added, and directories for
│ │ │ │ │  which p returns true are traversed. p must have the following signature:
│ │ │ │ │  bool Pred(std::string const& p);
│ │ │ │ │  The path that is passed in to the predicate is the full path of the file or
│ │ │ │ │ @@ -349,29 +349,29 @@
│ │ │ │ │  The ".." directory is never traversed.
│ │ │ │ │  The flags argument should be the same as the flags passed to the _c_r_e_a_t_e___t_o_r_r_e_n_t
│ │ │ │ │  constructor.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ sseett__ppiieeccee__hhaasshheess(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_r_e_a_t_e___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │  void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ │ -   , std::function const& f, error_code& ec);
│ │ │ │ │ -void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │     , std::function const& f, error_code& ec);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p,
│ │ │ │ │ -error_code& ec);
│ │ │ │ │  inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │  inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │     , settings_interface const& settings
│ │ │ │ │     , std::function const& f);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ +   , std::function const& f);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p,
│ │ │ │ │ +error_code& ec);
│ │ │ │ │ +void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ +   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ │ +   , std::function const& f, error_code& ec);
│ │ │ │ │  void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │     , settings_interface const& settings
│ │ │ │ │     , std::function const& f, error_code& ec);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , std::function const& f);
│ │ │ │ │  This function will assume that the files added to the torrent file exists at
│ │ │ │ │  path p, read those files and hash the content and set the hashes in the
│ │ │ │ │  create_torrent object. The optional function f is called in between every hash
│ │ │ │ │  that is set. f must have the following signature:
│ │ │ │ │  void Fun(piece_index_t);
│ │ │ │ │  The overloads taking a _s_e_t_t_i_n_g_s___p_a_c_k may be used to configure the underlying
│ │ │ │ │  disk access. Such as settings_pack::aio_threads.
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Custom_Storage.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -133,21 +133,21 @@
│ │ │ │  the constructor. The callbacks will be run in the network thread.

│ │ │ │  
│ │ │ │  struct disk_interface
│ │ │ │  {
│ │ │ │     virtual storage_holder new_torrent (storage_params const& p
│ │ │ │        , std::shared_ptr<void> const& torrent) = 0;
│ │ │ │     virtual void remove_torrent (storage_index_t) = 0;
│ │ │ │ +   virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ +      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ +      , disk_job_flags_t flags = {}) = 0;
│ │ │ │     virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ │        , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ │        , std::function<void(storage_error const&)> handler
│ │ │ │        , disk_job_flags_t flags = {}) = 0;
│ │ │ │ -   virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ -      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ -      , disk_job_flags_t flags = {}) = 0;
│ │ │ │     virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ │        , disk_job_flags_t flags
│ │ │ │        , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │ │     virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ │        , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │ │     virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ │        , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │ │ @@ -204,21 +204,21 @@
│ │ │ │  delete any files from disk, just to clean up any resources associated
│ │ │ │  with the specified storage.

│ │ │ │  
│ │ │ │  [report issue]
│ │ │ │
│ │ │ │

async_read() async_write()

│ │ │ │ 
│ │ │ │ +virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ +      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ +      , disk_job_flags_t flags = {}) = 0;
│ │ │ │  virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ │        , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ │        , std::function<void(storage_error const&)> handler
│ │ │ │        , disk_job_flags_t flags = {}) = 0;
│ │ │ │ -virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ -      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ -      , disk_job_flags_t flags = {}) = 0;
│ │ │ │
│ │ │ │

perform a read or write operation from/to the specified storage │ │ │ │ index and the specified request. When the operation completes, call │ │ │ │ handler possibly with a disk_buffer_holder, holding the buffer with │ │ │ │ the result. Flags may be set to affect the read operation. See │ │ │ │ disk_job_flags_t.

│ │ │ │

The disk_observer is a callback to indicate that │ │ │ │ @@ -469,22 +469,22 @@ │ │ │ │ internal libtorrent torrent object to tie the storage object allocated │ │ │ │ for a torrent to the lifetime of the internal torrent object. When a │ │ │ │ torrent is removed from the session, this holder is destructed and will │ │ │ │ inform the disk object.

│ │ │ │ 
│ │ │ │  struct storage_holder
│ │ │ │  {
│ │ │ │ -   storage_holder () = default;
│ │ │ │ -   ~storage_holder ();
│ │ │ │     storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ +   ~storage_holder ();
│ │ │ │ +   storage_holder () = default;
│ │ │ │     explicit operator bool () const;
│ │ │ │     operator storage_index_t () const;
│ │ │ │     void reset ();
│ │ │ │ -   storage_holder& operator= (storage_holder const&) = delete;
│ │ │ │     storage_holder (storage_holder const&) = delete;
│ │ │ │ +   storage_holder& operator= (storage_holder const&) = delete;
│ │ │ │     storage_holder (storage_holder&& rhs) noexcept;
│ │ │ │     storage_holder& operator= (storage_holder&& rhs) noexcept;
│ │ │ │  };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │

disk_observer

│ │ │ │ @@ -610,21 +610,21 @@ │ │ │ │

settings_interface

│ │ │ │

Declared in "libtorrent/settings_pack.hpp"

│ │ │ │

the common interface to settings_pack and the internal representation of │ │ │ │ settings.

│ │ │ │ 
│ │ │ │  struct settings_interface
│ │ │ │  {
│ │ │ │ +   virtual void set_bool (int name, bool val) = 0;
│ │ │ │     virtual void set_str (int name, std::string val) = 0;
│ │ │ │     virtual void set_int (int name, int val) = 0;
│ │ │ │     virtual bool has_val (int name) const = 0;
│ │ │ │ -   virtual void set_bool (int name, bool val) = 0;
│ │ │ │ -   virtual bool get_bool (int name) const = 0;
│ │ │ │     virtual std::string const& get_str (int name) const = 0;
│ │ │ │     virtual int get_int (int name) const = 0;
│ │ │ │ +   virtual bool get_bool (int name) const = 0;
│ │ │ │  };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │

file_open_mode_t

│ │ │ │

Declared in "libtorrent/disk_interface.hpp"

│ │ │ │
│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -90,21 +90,21 @@ │ │ │ │ │ thread via the io_context object passed into the constructor. The callbacks │ │ │ │ │ will be run in the network thread. │ │ │ │ │ struct disk_interface │ │ │ │ │ { │ │ │ │ │ virtual storage_holder nneeww__ttoorrrreenntt (storage_params const& p │ │ │ │ │ , std::shared_ptr const& torrent) = 0; │ │ │ │ │ virtual void rreemmoovvee__ttoorrrreenntt (storage_index_t) = 0; │ │ │ │ │ + virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ + , std::function handler │ │ │ │ │ + , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ virtual bool aassyynncc__wwrriittee (storage_index_t storage, peer_request const& r │ │ │ │ │ , char const* buf, std::shared_ptr o │ │ │ │ │ , std::function handler │ │ │ │ │ , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ - virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ - , std::function handler │ │ │ │ │ - , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ virtual void aassyynncc__hhaasshh (storage_index_t storage, piece_index_t piece, │ │ │ │ │ span v2 │ │ │ │ │ , disk_job_flags_t flags │ │ │ │ │ , std::function handler) = 0; │ │ │ │ │ virtual void aassyynncc__hhaasshh22 (storage_index_t storage, piece_index_t piece, int │ │ │ │ │ offset, disk_job_flags_t flags │ │ │ │ │ @@ -160,21 +160,21 @@ │ │ │ │ │ ********** rreemmoovvee__ttoorrrreenntt(()) ********** │ │ │ │ │ virtual void rreemmoovvee__ttoorrrreenntt (storage_index_t) = 0; │ │ │ │ │ remove the storage with the specified index. This is not expected to delete any │ │ │ │ │ files from disk, just to clean up any resources associated with the specified │ │ │ │ │ storage. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aassyynncc__rreeaadd(()) aassyynncc__wwrriittee(()) ********** │ │ │ │ │ +virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ + , std::function handler │ │ │ │ │ + , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ virtual bool aassyynncc__wwrriittee (storage_index_t storage, peer_request const& r │ │ │ │ │ , char const* buf, std::shared_ptr o │ │ │ │ │ , std::function handler │ │ │ │ │ , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ -virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ - , std::function handler │ │ │ │ │ - , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ perform a read or write operation from/to the specified storage index and the │ │ │ │ │ specified request. When the operation completes, call handler possibly with a │ │ │ │ │ _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r, holding the buffer with the result. Flags may be set to │ │ │ │ │ affect the read operation. See disk_job_flags_t. │ │ │ │ │ The _d_i_s_k___o_b_s_e_r_v_e_r is a callback to indicate that the store buffer/disk write │ │ │ │ │ queue is below the watermark to let peers start writing buffers to disk again. │ │ │ │ │ When async_write() returns true, indicating the write queue is full, the peer │ │ │ │ │ @@ -361,22 +361,22 @@ │ │ │ │ │ a unique, owning, reference to the storage of a torrent in a disk io subsystem │ │ │ │ │ (class that implements _d_i_s_k___i_n_t_e_r_f_a_c_e). This is held by the internal libtorrent │ │ │ │ │ torrent object to tie the storage object allocated for a torrent to the │ │ │ │ │ lifetime of the internal torrent object. When a torrent is removed from the │ │ │ │ │ _s_e_s_s_i_o_n, this holder is destructed and will inform the disk object. │ │ │ │ │ struct storage_holder │ │ │ │ │ { │ │ │ │ │ - ssttoorraaggee__hhoollddeerr () = default; │ │ │ │ │ - ~~ssttoorraaggee__hhoollddeerr (); │ │ │ │ │ ssttoorraaggee__hhoollddeerr (storage_index_t idx, disk_interface& disk_io); │ │ │ │ │ + ~~ssttoorraaggee__hhoollddeerr (); │ │ │ │ │ + ssttoorraaggee__hhoollddeerr () = default; │ │ │ │ │ explicit operator bbooooll () const; │ │ │ │ │ operator ssttoorraaggee__iinnddeexx__tt () const; │ │ │ │ │ void rreesseett (); │ │ │ │ │ - storage_holder& ooppeerraattoorr== (storage_holder const&) = delete; │ │ │ │ │ ssttoorraaggee__hhoollddeerr (storage_holder const&) = delete; │ │ │ │ │ + storage_holder& ooppeerraattoorr== (storage_holder const&) = delete; │ │ │ │ │ ssttoorraaggee__hhoollddeerr (storage_holder&& rhs) noexcept; │ │ │ │ │ storage_holder& ooppeerraattoorr== (storage_holder&& rhs) noexcept; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ddiisskk__oobbsseerrvveerr ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___o_b_s_e_r_v_e_r_._h_p_p" │ │ │ │ │ struct disk_observer │ │ │ │ │ @@ -460,21 +460,21 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseettttiinnggss__iinntteerrffaaccee ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p" │ │ │ │ │ the common interface to _s_e_t_t_i_n_g_s___p_a_c_k and the internal representation of │ │ │ │ │ settings. │ │ │ │ │ struct settings_interface │ │ │ │ │ { │ │ │ │ │ + virtual void sseett__bbooooll (int name, bool val) = 0; │ │ │ │ │ virtual void sseett__ssttrr (int name, std::string val) = 0; │ │ │ │ │ virtual void sseett__iinntt (int name, int val) = 0; │ │ │ │ │ virtual bool hhaass__vvaall (int name) const = 0; │ │ │ │ │ - virtual void sseett__bbooooll (int name, bool val) = 0; │ │ │ │ │ - virtual bool ggeett__bbooooll (int name) const = 0; │ │ │ │ │ virtual std::string const& ggeett__ssttrr (int name) const = 0; │ │ │ │ │ virtual int ggeett__iinntt (int name) const = 0; │ │ │ │ │ + virtual bool ggeett__bbooooll (int name) const = 0; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ffiillee__ooppeenn__mmooddee__tt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___i_n_t_e_r_f_a_c_e_._h_p_p" │ │ │ │ │ read_only │ │ │ │ │ open the file for reading only │ │ │ │ │ write_only │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Error_Codes.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -61,16 +61,16 @@ │ │ │ │

used by storage to return errors │ │ │ │ also includes which underlying file the │ │ │ │ error happened on

│ │ │ │ 
│ │ │ │  struct storage_error
│ │ │ │  {
│ │ │ │     explicit operator bool () const;
│ │ │ │ -   file_index_t file () const;
│ │ │ │     void file (file_index_t f);
│ │ │ │ +   file_index_t file () const;
│ │ │ │  
│ │ │ │     error_code ec;
│ │ │ │     operation_t operation;
│ │ │ │  };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │

bool()

│ │ │ │ @@ -79,16 +79,16 @@ │ │ │ │ │ │ │ │

explicitly converts to true if this object represents an error, and │ │ │ │ false if it does not.

│ │ │ │ [report issue]
│ │ │ │
│ │ │ │

file()

│ │ │ │ 
│ │ │ │ -file_index_t file () const;
│ │ │ │  void file (file_index_t f);
│ │ │ │ +file_index_t file () const;
│ │ │ │
│ │ │ │

set and query the index (in the torrent) of the file this error │ │ │ │ occurred on. This may also have special values defined in │ │ │ │ torrent_status.

│ │ │ │ [report issue]
│ │ │ │
ec
│ │ │ │
the error that occurred
│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -26,29 +26,29 @@ │ │ │ │ │ ************ ssttoorraaggee__eerrrroorr ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p" │ │ │ │ │ used by storage to return errors also includes which underlying file the error │ │ │ │ │ happened on │ │ │ │ │ struct storage_error │ │ │ │ │ { │ │ │ │ │ explicit operator bbooooll () const; │ │ │ │ │ - file_index_t ffiillee () const; │ │ │ │ │ void ffiillee (file_index_t f); │ │ │ │ │ + file_index_t ffiillee () const; │ │ │ │ │ │ │ │ │ │ error_code ec; │ │ │ │ │ operation_t operation; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** bbooooll(()) ********** │ │ │ │ │ explicit operator bbooooll () const; │ │ │ │ │ explicitly converts to true if this object represents an error, and false if it │ │ │ │ │ does not. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiillee(()) ********** │ │ │ │ │ -file_index_t ffiillee () const; │ │ │ │ │ void ffiillee (file_index_t f); │ │ │ │ │ +file_index_t ffiillee () const; │ │ │ │ │ set and query the index (in the torrent) of the file this error occurred on. │ │ │ │ │ This may also have special values defined in _t_o_r_r_e_n_t___s_t_a_t_u_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ec │ │ │ │ │ the error that occurred │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ operation │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Filter.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -56,20 +56,20 @@ │ │ │ │ a single rule that allows all addresses (0.0.0.0 - 255.255.255.255 for │ │ │ │ the IPv4 range, and the equivalent range covering all addresses for the │ │ │ │ IPv6 range).

│ │ │ │

A default constructed ip_filter does not filter any address.

│ │ │ │ 
│ │ │ │  struct ip_filter
│ │ │ │  {
│ │ │ │ -   ip_filter (ip_filter const&);
│ │ │ │ -   ip_filter& operator= (ip_filter&&);
│ │ │ │ -   ip_filter (ip_filter&&);
│ │ │ │ -   ~ip_filter ();
│ │ │ │     ip_filter ();
│ │ │ │ +   ~ip_filter ();
│ │ │ │ +   ip_filter (ip_filter&&);
│ │ │ │     ip_filter& operator= (ip_filter const&);
│ │ │ │ +   ip_filter (ip_filter const&);
│ │ │ │ +   ip_filter& operator= (ip_filter&&);
│ │ │ │     bool empty () const;
│ │ │ │     void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (address const& addr) const;
│ │ │ │     filter_tuple_t export_filter () const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │     {
│ │ │ │ @@ -153,20 +153,20 @@
│ │ │ │  
the port filter maps non-overlapping port ranges to flags. This
│ │ │ │  is primarily used to indicate whether a range of ports should
│ │ │ │  be connected to or not. The default is to have the full port
│ │ │ │  range (0-65535) set to flag 0.

│ │ │ │  
│ │ │ │  class port_filter
│ │ │ │  {
│ │ │ │ -   port_filter& operator= (port_filter const&);
│ │ │ │ +   port_filter ();
│ │ │ │     ~port_filter ();
│ │ │ │     port_filter& operator= (port_filter&&);
│ │ │ │ -   port_filter ();
│ │ │ │ -   port_filter (port_filter&&);
│ │ │ │ +   port_filter& operator= (port_filter const&);
│ │ │ │     port_filter (port_filter const&);
│ │ │ │ +   port_filter (port_filter&&);
│ │ │ │     void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (std::uint16_t port) const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │     {
│ │ │ │        blocked,
│ │ │ │     };
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -19,20 +19,20 @@
│ │ │ │ │  The ip_filter class is a set of rules that uniquely categorizes all ip
│ │ │ │ │  addresses as allowed or disallowed. The default constructor creates a single
│ │ │ │ │  rule that allows all addresses (0.0.0.0 - 255.255.255.255 for the IPv4 range,
│ │ │ │ │  and the equivalent range covering all addresses for the IPv6 range).
│ │ │ │ │  A default constructed _i_p___f_i_l_t_e_r does not filter any address.
│ │ │ │ │  struct ip_filter
│ │ │ │ │  {
│ │ │ │ │ -   iipp__ffiilltteerr (ip_filter const&);
│ │ │ │ │ -   ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ -   iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ -   ~~iipp__ffiilltteerr ();
│ │ │ │ │     iipp__ffiilltteerr ();
│ │ │ │ │ +   ~~iipp__ffiilltteerr ();
│ │ │ │ │ +   iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │ +   iipp__ffiilltteerr (ip_filter const&);
│ │ │ │ │ +   ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │     bool eemmppttyy () const;
│ │ │ │ │     void aadddd__rruullee (address const& first, address const& last, std::uint32_t
│ │ │ │ │  flags);
│ │ │ │ │     std::uint32_t aacccceessss (address const& addr) const;
│ │ │ │ │     filter_tuple_t eexxppoorrtt__ffiilltteerr () const;
│ │ │ │ │  
│ │ │ │ │     enum access_flags
│ │ │ │ │ @@ -81,20 +81,20 @@
│ │ │ │ │  ************ ppoorrtt__ffiilltteerr ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_p___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │  the port filter maps non-overlapping port ranges to flags. This is primarily
│ │ │ │ │  used to indicate whether a range of ports should be connected to or not. The
│ │ │ │ │  default is to have the full port range (0-65535) set to flag 0.
│ │ │ │ │  class port_filter
│ │ │ │ │  {
│ │ │ │ │ -   port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ +   ppoorrtt__ffiilltteerr ();
│ │ │ │ │     ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ -   ppoorrtt__ffiilltteerr ();
│ │ │ │ │ -   ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ +   port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │     ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │ +   ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │     void aadddd__rruullee (std::uint16_t first, std::uint16_t last, std::uint32_t
│ │ │ │ │  flags);
│ │ │ │ │     std::uint32_t aacccceessss (std::uint16_t port) const;
│ │ │ │ │  
│ │ │ │ │     enum access_flags
│ │ │ │ │     {
│ │ │ │ │        blocked,
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Plugins.html
│ │ │ │ @@ -48,30 +48,30 @@
│ │ │ │  
  • load_state()
    • 
│ │ │ │  
│ │ │ │  
│ │ │ │  
  • torrent_plugin
│ │ │ │  
    • 
│ │ │ │  
  • peer_plugin
      
│ │ │ │  
    • type()
      • 
│ │ │ │  
    • add_handshake()
      • 
│ │ │ │  
    • on_disconnect()
      • 
│ │ │ │  
    • on_connected()
      • 
│ │ │ │  
    • on_handshake()
      • 
│ │ │ │  
    • on_extension_handshake()
      • 
│ │ │ │ -
    • on_have() on_allowed_fast() on_request() on_have_all() on_dont_have() on_bitfield() on_not_interested() on_have_none() on_unchoke() on_choke() on_interested()
      • 
│ │ │ │ +
    • on_dont_have() on_allowed_fast() on_have_none() on_choke() on_unchoke() on_request() on_have_all() on_bitfield() on_interested() on_not_interested() on_have()
      • 
│ │ │ │  
    • on_piece()
      • 
│ │ │ │ -
    • sent_unchoke() sent_interested() sent_have() sent_not_interested() sent_piece()
      • 
│ │ │ │ +
    • sent_have() sent_unchoke() sent_piece() sent_not_interested() sent_interested()
      • 
│ │ │ │  
    • sent_payload()
      • 
│ │ │ │  
    • can_disconnect()
      • 
│ │ │ │  
    • on_extended()
      • 
│ │ │ │  
    • on_unknown_message()
      • 
│ │ │ │  
    • on_piece_failed() on_piece_pass()
      • 
│ │ │ │  
    • tick()
      • 
│ │ │ │  
    • write_request()
      • 
│ │ │ │ @@ -396,18 +396,18 @@
│ │ │ │  
      
│ │ │ │  
      tick()
      
│ │ │ │  
      │ │ │ │  virtual void tick ();
│ │ │ │  
      
│ │ │ │  
      This hook is called approximately once per second. It is a way of making it
│ │ │ │  easy for plugins to do timed events, for sending messages or whatever.
      
│ │ │ │ -
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      on_resume() on_pause()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      on_pause() on_resume()
      
│ │ │ │  
      │ │ │ │  virtual bool on_resume ();
│ │ │ │  virtual bool on_pause ();
│ │ │ │  
      
│ │ │ │  
      These hooks are called when the torrent is paused and resumed respectively.
│ │ │ │  The return value indicates if the event was handled. A return value of
│ │ │ │  true indicates that it was handled, and no other plugin after this one
│ │ │ │ @@ -475,43 +475,43 @@
│ │ │ │  {
│ │ │ │     virtual string_view type () const;
│ │ │ │     virtual void add_handshake (entry&);
│ │ │ │     virtual void on_disconnect (error_code const&);
│ │ │ │     virtual void on_connected ();
│ │ │ │     virtual bool on_handshake (span<char const>);
│ │ │ │     virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │ -   virtual bool on_have (piece_index_t);
│ │ │ │ -   virtual bool on_unchoke ();
│ │ │ │ -   virtual bool on_request (peer_request const&);
│ │ │ │ -   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -   virtual bool on_interested ();
│ │ │ │ -   virtual bool on_dont_have (piece_index_t);
│ │ │ │     virtual bool on_have_all ();
│ │ │ │ -   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +   virtual bool on_dont_have (piece_index_t);
│ │ │ │     virtual bool on_have_none ();
│ │ │ │     virtual bool on_not_interested ();
│ │ │ │ +   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +   virtual bool on_request (peer_request const&);
│ │ │ │ +   virtual bool on_have (piece_index_t);
│ │ │ │     virtual bool on_choke ();
│ │ │ │ +   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +   virtual bool on_interested ();
│ │ │ │ +   virtual bool on_unchoke ();
│ │ │ │     virtual bool on_piece (peer_request const& /*piece*/
│ │ │ │        , span<char const> /*buf*/);
│ │ │ │     virtual bool on_suggest (piece_index_t);
│ │ │ │ -   virtual bool on_reject (peer_request const&);
│ │ │ │     virtual bool on_cancel (peer_request const&);
│ │ │ │ -   virtual void sent_reject_request (peer_request const&);
│ │ │ │ +   virtual bool on_reject (peer_request const&);
│ │ │ │     virtual void sent_cancel (peer_request const&);
│ │ │ │ -   virtual void sent_request (peer_request const&);
│ │ │ │ -   virtual void sent_suggest (piece_index_t);
│ │ │ │     virtual void sent_have_none ();
│ │ │ │ -   virtual void sent_allow_fast (piece_index_t);
│ │ │ │     virtual void sent_choke ();
│ │ │ │ +   virtual void sent_suggest (piece_index_t);
│ │ │ │ +   virtual void sent_allow_fast (piece_index_t);
│ │ │ │ +   virtual void sent_request (peer_request const&);
│ │ │ │ +   virtual void sent_reject_request (peer_request const&);
│ │ │ │     virtual void sent_have_all ();
│ │ │ │ -   virtual void sent_have (piece_index_t);
│ │ │ │ -   virtual void sent_unchoke ();
│ │ │ │ -   virtual void sent_not_interested ();
│ │ │ │     virtual void sent_piece (peer_request const&);
│ │ │ │ +   virtual void sent_have (piece_index_t);
│ │ │ │     virtual void sent_interested ();
│ │ │ │ +   virtual void sent_not_interested ();
│ │ │ │ +   virtual void sent_unchoke ();
│ │ │ │     virtual void sent_payload (int /* bytes */);
│ │ │ │     virtual bool can_disconnect (error_code const& /*ec*/);
│ │ │ │     virtual bool on_extended (int /*length*/, int /*msg*/,
│ │ │ │        span<char const> /*body*/);
│ │ │ │     virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │        span<char const> /*body*/);
│ │ │ │     virtual void on_piece_failed (piece_index_t);
│ │ │ │ @@ -569,39 +569,39 @@
│ │ │ │  virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │  
    • 
│ │ │ │  
    called when the extension handshake from the other end is received
│ │ │ │  if this returns false, it means that this extension isn't
│ │ │ │  supported by this peer. It will result in this peer_plugin
│ │ │ │  being removed from the peer_connection and destructed.
│ │ │ │  this is not called for web seeds
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │  
│ │ │ │ -
│ │ │ │  
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    on_have() on_allowed_fast() on_request() on_have_all() on_dont_have() on_bitfield() on_not_interested() on_have_none() on_unchoke() on_choke() on_interested()

    │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    on_dont_have() on_allowed_fast() on_have_none() on_choke() on_unchoke() on_request() on_have_all() on_bitfield() on_interested() on_not_interested() on_have()

    │ │ │ │ 
    │ │ │ │ -virtual bool on_have (piece_index_t);
│ │ │ │ -virtual bool on_unchoke ();
│ │ │ │ -virtual bool on_request (peer_request const&);
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -virtual bool on_interested ();
│ │ │ │ -virtual bool on_dont_have (piece_index_t);
│ │ │ │  virtual bool on_have_all ();
│ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +virtual bool on_dont_have (piece_index_t);
│ │ │ │  virtual bool on_have_none ();
│ │ │ │  virtual bool on_not_interested ();
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +virtual bool on_request (peer_request const&);
│ │ │ │ +virtual bool on_have (piece_index_t);
│ │ │ │  virtual bool on_choke ();
│ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +virtual bool on_interested ();
│ │ │ │ +virtual bool on_unchoke ();
│ │ │ │
    │ │ │ │

    returning true from any of the message handlers │ │ │ │ indicates that the plugin has handled the message. │ │ │ │ it will break the plugin chain traversing and not let │ │ │ │ anyone else handle the message, including the default │ │ │ │ handler.

    │ │ │ │ [report issue]
    │ │ │ │ @@ -613,27 +613,27 @@ │ │ │ │ │ │ │ │

    This function is called when the peer connection is receiving │ │ │ │ a piece. buf points (non-owning pointer) to the data in an │ │ │ │ internal immutable disk buffer. The length of the data is specified │ │ │ │ in the length member of the piece parameter. │ │ │ │ returns true to indicate that the piece is handled and the │ │ │ │ rest of the logic should be ignored.

    │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    sent_unchoke() sent_interested() sent_have() sent_not_interested() sent_piece()

    │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    sent_have() sent_unchoke() sent_piece() sent_not_interested() sent_interested()

    │ │ │ │ 
    │ │ │ │ -virtual void sent_have (piece_index_t);
│ │ │ │ -virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_not_interested ();
│ │ │ │  virtual void sent_piece (peer_request const&);
│ │ │ │ +virtual void sent_have (piece_index_t);
│ │ │ │  virtual void sent_interested ();
│ │ │ │ +virtual void sent_not_interested ();
│ │ │ │ +virtual void sent_unchoke ();
│ │ │ │
    │ │ │ │

    called after a choke message has been sent to the peer

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    sent_payload()

    │ │ │ │ 
    │ │ │ │  virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -736,37 +736,37 @@
│ │ │ │  connection object, to be used by plugins. This is a low level interface that
│ │ │ │  may not be stable across libtorrent versions
    
│ │ │ │  
    │ │ │ │  struct peer_connection_handle
│ │ │ │  {
│ │ │ │     explicit peer_connection_handle (std::weak_ptr<peer_connection> impl);
│ │ │ │     connection_type type () const;
│ │ │ │ -   void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │     peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ +   void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │     bool is_seed () const;
│ │ │ │     bool upload_only () const;
│ │ │ │ -   bool has_piece (piece_index_t i) const;
│ │ │ │     peer_id const& pid () const;
│ │ │ │ -   bool is_choked () const;
│ │ │ │ +   bool has_piece (piece_index_t i) const;
│ │ │ │     bool is_interesting () const;
│ │ │ │ +   bool is_choked () const;
│ │ │ │     bool is_peer_interested () const;
│ │ │ │     bool has_peer_choked () const;
│ │ │ │ -   void choke_this_peer ();
│ │ │ │     void maybe_unchoke_this_peer ();
│ │ │ │ +   void choke_this_peer ();
│ │ │ │     void get_peer_info (peer_info& p) const;
│ │ │ │     torrent_handle associated_torrent () const;
│ │ │ │     tcp::endpoint const& remote () const;
│ │ │ │     tcp::endpoint local_endpoint () const;
│ │ │ │ +   bool is_outgoing () const;
│ │ │ │ +   bool is_disconnecting () const;
│ │ │ │     bool is_connecting () const;
│ │ │ │     void disconnect (error_code const& ec, operation_t op
│ │ │ │        , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ -   bool is_outgoing () const;
│ │ │ │ -   bool is_disconnecting () const;
│ │ │ │ -   bool ignore_unchoke_slots () const;
│ │ │ │     bool on_local_network () const;
│ │ │ │ +   bool ignore_unchoke_slots () const;
│ │ │ │     bool failed () const;
│ │ │ │     bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ │     void peer_log (peer_log_alert::direction_t direction
│ │ │ │        , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT(4,5);
│ │ │ │     bool can_disconnect (error_code const& ec) const;
│ │ │ │     bool has_metadata () const;
│ │ │ │     bool in_handshake () const;
│ │ │ │ @@ -789,16 +789,16 @@
│ │ │ │  
    │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │  {
│ │ │ │     explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │     bool support_extensions () const;
│ │ │ │     bool packet_finished () const;
│ │ │ │     bool supports_encryption () const;
│ │ │ │ -   void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │     void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ +   void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │     std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    create_ut_pex_plugin()

    │ │ │ │

    Declared in "libtorrent/extensions/ut_pex.hpp"

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -17,31 +17,31 @@ │ │ │ │ │ o _o_n___t_i_c_k_(_) │ │ │ │ │ o _g_e_t___u_n_c_h_o_k_e___p_r_i_o_r_i_t_y_(_) │ │ │ │ │ o _l_o_a_d___s_t_a_t_e_(_) │ │ │ │ │ * _t_o_r_r_e_n_t___p_l_u_g_i_n │ │ │ │ │ o _n_e_w___c_o_n_n_e_c_t_i_o_n_(_) │ │ │ │ │ o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_) │ │ │ │ │ o _t_i_c_k_(_) │ │ │ │ │ - o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_e_(_) │ │ │ │ │ + o _o_n___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_) │ │ │ │ │ o _o_n___f_i_l_e_s___c_h_e_c_k_e_d_(_) │ │ │ │ │ o _o_n___s_t_a_t_e_(_) │ │ │ │ │ o _o_n___a_d_d___p_e_e_r_(_) │ │ │ │ │ * _p_e_e_r___p_l_u_g_i_n │ │ │ │ │ o _t_y_p_e_(_) │ │ │ │ │ o _a_d_d___h_a_n_d_s_h_a_k_e_(_) │ │ │ │ │ o _o_n___d_i_s_c_o_n_n_e_c_t_(_) │ │ │ │ │ o _o_n___c_o_n_n_e_c_t_e_d_(_) │ │ │ │ │ o _o_n___h_a_n_d_s_h_a_k_e_(_) │ │ │ │ │ o _o_n___e_x_t_e_n_s_i_o_n___h_a_n_d_s_h_a_k_e_(_) │ │ │ │ │ - o _o_n___h_a_v_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___d_o_n_t___h_a_v_e │ │ │ │ │ - _(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___u_n_c_h_o_k_e_(_) │ │ │ │ │ - _o_n___c_h_o_k_e_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_) │ │ │ │ │ + o _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___c_h_o_k_e_(_) │ │ │ │ │ + _o_n___u_n_c_h_o_k_e_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d │ │ │ │ │ + _(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e_(_) │ │ │ │ │ o _o_n___p_i_e_c_e_(_) │ │ │ │ │ - o _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_) │ │ │ │ │ - _s_e_n_t___p_i_e_c_e_(_) │ │ │ │ │ + o _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_) │ │ │ │ │ + _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_) │ │ │ │ │ o _s_e_n_t___p_a_y_l_o_a_d_(_) │ │ │ │ │ o _c_a_n___d_i_s_c_o_n_n_e_c_t_(_) │ │ │ │ │ o _o_n___e_x_t_e_n_d_e_d_(_) │ │ │ │ │ o _o_n___u_n_k_n_o_w_n___m_e_s_s_a_g_e_(_) │ │ │ │ │ o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_) │ │ │ │ │ o _t_i_c_k_(_) │ │ │ │ │ o _w_r_i_t_e___r_e_q_u_e_s_t_(_) │ │ │ │ │ @@ -298,15 +298,15 @@ │ │ │ │ │ through the torrent and the piece_picker. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttiicckk(()) ********** │ │ │ │ │ virtual void ttiicckk (); │ │ │ │ │ This hook is called approximately once per second. It is a way of making it │ │ │ │ │ easy for plugins to do timed events, for sending messages or whatever. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** oonn__rreessuummee(()) oonn__ppaauussee(()) ********** │ │ │ │ │ +********** oonn__ppaauussee(()) oonn__rreessuummee(()) ********** │ │ │ │ │ virtual bool oonn__rreessuummee (); │ │ │ │ │ virtual bool oonn__ppaauussee (); │ │ │ │ │ These hooks are called when the torrent is paused and resumed respectively. The │ │ │ │ │ return value indicates if the event was handled. A return value of true │ │ │ │ │ indicates that it was handled, and no other _p_l_u_g_i_n after this one will have │ │ │ │ │ this hook function called, and the standard handler will also not be invoked. │ │ │ │ │ So, returning true effectively overrides the standard behavior of pause or │ │ │ │ │ @@ -354,43 +354,43 @@ │ │ │ │ │ { │ │ │ │ │ virtual string_view ttyyppee () const; │ │ │ │ │ virtual void aadddd__hhaannddsshhaakkee (entry&); │ │ │ │ │ virtual void oonn__ddiissccoonnnneecctt (error_code const&); │ │ │ │ │ virtual void oonn__ccoonnnneecctteedd (); │ │ │ │ │ virtual bool oonn__hhaannddsshhaakkee (span); │ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&); │ │ │ │ │ - virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ - virtual bool oonn__uunncchhookkee (); │ │ │ │ │ - virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ - virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ - virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ - virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ - virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ + virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ + virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ + virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ + virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ virtual bool oonn__cchhookkee (); │ │ │ │ │ + virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ + virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ + virtual bool oonn__uunncchhookkee (); │ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**// │ │ │ │ │ , span //**bbuuff**//); │ │ │ │ │ virtual bool oonn__ssuuggggeesstt (piece_index_t); │ │ │ │ │ - virtual bool oonn__rreejjeecctt (peer_request const&); │ │ │ │ │ virtual bool oonn__ccaanncceell (peer_request const&); │ │ │ │ │ - virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&); │ │ │ │ │ + virtual bool oonn__rreejjeecctt (peer_request const&); │ │ │ │ │ virtual void sseenntt__ccaanncceell (peer_request const&); │ │ │ │ │ - virtual void sseenntt__rreeqquueesstt (peer_request const&); │ │ │ │ │ - virtual void sseenntt__ssuuggggeesstt (piece_index_t); │ │ │ │ │ virtual void sseenntt__hhaavvee__nnoonnee (); │ │ │ │ │ - virtual void sseenntt__aallllooww__ffaasstt (piece_index_t); │ │ │ │ │ virtual void sseenntt__cchhookkee (); │ │ │ │ │ + virtual void sseenntt__ssuuggggeesstt (piece_index_t); │ │ │ │ │ + virtual void sseenntt__aallllooww__ffaasstt (piece_index_t); │ │ │ │ │ + virtual void sseenntt__rreeqquueesstt (peer_request const&); │ │ │ │ │ + virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&); │ │ │ │ │ virtual void sseenntt__hhaavvee__aallll (); │ │ │ │ │ - virtual void sseenntt__hhaavvee (piece_index_t); │ │ │ │ │ - virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ - virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ + virtual void sseenntt__hhaavvee (piece_index_t); │ │ │ │ │ virtual void sseenntt__iinntteerreesstteedd (); │ │ │ │ │ + virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ + virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//); │ │ │ │ │ virtual bool ccaann__ddiissccoonnnneecctt (error_code const& //**eecc**//); │ │ │ │ │ virtual bool oonn__eexxtteennddeedd (int //**lleennggtthh**//, int //**mmssgg**//, │ │ │ │ │ span //**bbooddyy**//); │ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//, │ │ │ │ │ span //**bbooddyy**//); │ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t); │ │ │ │ │ @@ -426,48 +426,48 @@ │ │ │ │ │ ********** oonn__eexxtteennssiioonn__hhaannddsshhaakkee(()) ********** │ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&); │ │ │ │ │ called when the extension handshake from the other end is received if this │ │ │ │ │ returns false, it means that this extension isn't supported by this peer. It │ │ │ │ │ will result in this _p_e_e_r___p_l_u_g_i_n being removed from the peer_connection and │ │ │ │ │ destructed. this is not called for web seeds │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** oonn__hhaavvee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__rreeqquueesstt(()) oonn__hhaavvee__aallll(()) oonn__ddoonntt__hhaavvee(()) │ │ │ │ │ -oonn__bbiittffiieelldd(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__nnoonnee(()) oonn__uunncchhookkee(()) oonn__cchhookkee(()) │ │ │ │ │ -oonn__iinntteerreesstteedd(()) ********** │ │ │ │ │ -virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ -virtual bool oonn__uunncchhookkee (); │ │ │ │ │ -virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ -virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ -virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ +********** oonn__ddoonntt__hhaavvee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__hhaavvee__nnoonnee(()) oonn__cchhookkee(()) oonn__uunncchhookkee(()) │ │ │ │ │ +oonn__rreeqquueesstt(()) oonn__hhaavvee__aallll(()) oonn__bbiittffiieelldd(()) oonn__iinntteerreesstteedd(()) oonn__nnoott__iinntteerreesstteedd(()) │ │ │ │ │ +oonn__hhaavvee(()) ********** │ │ │ │ │ virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ +virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ +virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ +virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ virtual bool oonn__cchhookkee (); │ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ +virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ +virtual bool oonn__uunncchhookkee (); │ │ │ │ │ returning true from any of the message handlers indicates that the _p_l_u_g_i_n has │ │ │ │ │ handled the message. it will break the _p_l_u_g_i_n chain traversing and not let │ │ │ │ │ anyone else handle the message, including the default handler. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** oonn__ppiieeccee(()) ********** │ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**// │ │ │ │ │ , span //**bbuuff**//); │ │ │ │ │ This function is called when the peer connection is receiving a piece. buf │ │ │ │ │ points (non-owning pointer) to the data in an internal immutable disk buffer. │ │ │ │ │ The length of the data is specified in the length member of the piece │ │ │ │ │ parameter. returns true to indicate that the piece is handled and the rest of │ │ │ │ │ the logic should be ignored. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseenntt__uunncchhookkee(()) sseenntt__iinntteerreesstteedd(()) sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) │ │ │ │ │ -sseenntt__ppiieeccee(()) ********** │ │ │ │ │ -virtual void sseenntt__hhaavvee (piece_index_t); │ │ │ │ │ -virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ -virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ +********** sseenntt__hhaavvee(()) sseenntt__uunncchhookkee(()) sseenntt__ppiieeccee(()) sseenntt__nnoott__iinntteerreesstteedd(()) │ │ │ │ │ +sseenntt__iinntteerreesstteedd(()) ********** │ │ │ │ │ virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ +virtual void sseenntt__hhaavvee (piece_index_t); │ │ │ │ │ virtual void sseenntt__iinntteerreesstteedd (); │ │ │ │ │ +virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ +virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ called after a choke message has been sent to the peer │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseenntt__ppaayyllooaadd(()) ********** │ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//); │ │ │ │ │ called after piece data has been sent to the peer this can be used for stats │ │ │ │ │ book keeping │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -538,37 +538,37 @@ │ │ │ │ │ the _p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e class provides a handle to the internal peer │ │ │ │ │ connection object, to be used by plugins. This is a low level interface that │ │ │ │ │ may not be stable across libtorrent versions │ │ │ │ │ struct peer_connection_handle │ │ │ │ │ { │ │ │ │ │ explicit ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (std::weak_ptr impl); │ │ │ │ │ connection_type ttyyppee () const; │ │ │ │ │ - void aadddd__eexxtteennssiioonn (std::shared_ptr); │ │ │ │ │ peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const; │ │ │ │ │ + void aadddd__eexxtteennssiioonn (std::shared_ptr); │ │ │ │ │ bool iiss__sseeeedd () const; │ │ │ │ │ bool uuppllooaadd__oonnllyy () const; │ │ │ │ │ - bool hhaass__ppiieeccee (piece_index_t i) const; │ │ │ │ │ peer_id const& ppiidd () const; │ │ │ │ │ - bool iiss__cchhookkeedd () const; │ │ │ │ │ + bool hhaass__ppiieeccee (piece_index_t i) const; │ │ │ │ │ bool iiss__iinntteerreessttiinngg () const; │ │ │ │ │ + bool iiss__cchhookkeedd () const; │ │ │ │ │ bool iiss__ppeeeerr__iinntteerreesstteedd () const; │ │ │ │ │ bool hhaass__ppeeeerr__cchhookkeedd () const; │ │ │ │ │ - void cchhookkee__tthhiiss__ppeeeerr (); │ │ │ │ │ void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr (); │ │ │ │ │ + void cchhookkee__tthhiiss__ppeeeerr (); │ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (peer_info& p) const; │ │ │ │ │ torrent_handle aassssoocciiaatteedd__ttoorrrreenntt () const; │ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t const& rreemmoottee () const; │ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const; │ │ │ │ │ + bool iiss__oouuttggooiinngg () const; │ │ │ │ │ + bool iiss__ddiissccoonnnneeccttiinngg () const; │ │ │ │ │ bool iiss__ccoonnnneeccttiinngg () const; │ │ │ │ │ void ddiissccoonnnneecctt (error_code const& ec, operation_t op │ │ │ │ │ , disconnect_severity_t = peer_connection_interface::normal); │ │ │ │ │ - bool iiss__oouuttggooiinngg () const; │ │ │ │ │ - bool iiss__ddiissccoonnnneeccttiinngg () const; │ │ │ │ │ - bool iiggnnoorree__uunncchhookkee__sslloottss () const; │ │ │ │ │ bool oonn__llooccaall__nneettwwoorrkk () const; │ │ │ │ │ + bool iiggnnoorree__uunncchhookkee__sslloottss () const; │ │ │ │ │ bool ffaaiilleedd () const; │ │ │ │ │ bool sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const; │ │ │ │ │ void ppeeeerr__lloogg (peer_log_alert::direction_t direction │ │ │ │ │ , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT │ │ │ │ │ (4,5); │ │ │ │ │ bool ccaann__ddiissccoonnnneecctt (error_code const& ec) const; │ │ │ │ │ bool hhaass__mmeettaaddaattaa () const; │ │ │ │ │ @@ -589,16 +589,16 @@ │ │ │ │ │ libtorrent versions. │ │ │ │ │ struct bt_peer_connection_handle : peer_connection_handle │ │ │ │ │ { │ │ │ │ │ explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc); │ │ │ │ │ bool ssuuppppoorrtt__eexxtteennssiioonnss () const; │ │ │ │ │ bool ppaacckkeett__ffiinniisshheedd () const; │ │ │ │ │ bool ssuuppppoorrttss__eennccrryyppttiioonn () const; │ │ │ │ │ - void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto); │ │ │ │ │ void sswwiittcchh__sseenndd__ccrryyppttoo (std::shared_ptr crypto); │ │ │ │ │ + void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto); │ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ccrreeaattee__uutt__ppeexx__pplluuggiinn(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_/_u_t___p_e_x_._h_p_p" │ │ │ │ │ std::shared_ptr ccrreeaattee__uutt__ppeexx__pplluuggiinn (torrent_handle const&, │ │ │ │ │ client_data_t); │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Resume_Data.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -40,20 +40,20 @@ │ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    read_resume_data()

    │ │ │ │

    Declared in "libtorrent/read_resume_data.hpp"

    │ │ │ │ 
    │ │ │ │  add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │     , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ -add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ -   , int piece_limit = 0x200000);
│ │ │ │ -add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ -   , load_torrent_limits const& cfg = {});
│ │ │ │  add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │     , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ +add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ +   , load_torrent_limits const& cfg = {});
│ │ │ │ +add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ +   , int piece_limit = 0x200000);
│ │ │ │
    │ │ │ │

    these functions are used to parse resume data and populate the appropriate │ │ │ │ fields in an add_torrent_params object. This object can then be used to add │ │ │ │ the actual torrent_info object to and pass to session::add_torrent() or │ │ │ │ session::async_add_torrent().

    │ │ │ │

    If the client wants to override any field that was loaded from the resume │ │ │ │ data, e.g. save_path, those fields must be changed after loading resume │ │ │ │ @@ -67,29 +67,29 @@ │ │ │ │ to torrent_info::parse_info_section().

    │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    write_resume_data() write_resume_data_buf()

    │ │ │ │

    Declared in "libtorrent/write_resume_data.hpp"

    │ │ │ │ 
    │ │ │ │ -entry write_resume_data (add_torrent_params const& atp);
│ │ │ │  std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │ +entry write_resume_data (add_torrent_params const& atp);
│ │ │ │
    │ │ │ │

    this function turns the resume data in an add_torrent_params object │ │ │ │ into a bencoded structure

    │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    write_torrent_file() write_torrent_file_buf()

    │ │ │ │

    Declared in "libtorrent/write_resume_data.hpp"

    │ │ │ │ 
    │ │ │ │  std::vector<char> write_torrent_file_buf (add_torrent_params const& atp
│ │ │ │     , write_torrent_flags_t flags);
│ │ │ │ -entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │  entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │
    │ │ │ │

    writes only the fields to create a .torrent file. This function may fail │ │ │ │ with a std::system_error exception if:

    │ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    session_params

    │ │ │ │

    Declared in "libtorrent/session_params.hpp"

    │ │ │ │

    The session_params is a parameters pack for configuring the session │ │ │ │ before it's started.

    │ │ │ │ 
    │ │ │ │  struct session_params
│ │ │ │  {
│ │ │ │ +   session_params ();
│ │ │ │     session_params (settings_pack&& sp);
│ │ │ │     session_params (settings_pack const& sp);
│ │ │ │ -   session_params ();
│ │ │ │     session_params (settings_pack const& sp
│ │ │ │        , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │     session_params (settings_pack&& sp
│ │ │ │        , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │  
│ │ │ │     settings_pack settings;
│ │ │ │     std::vector<std::shared_ptr<plugin>> extensions;
│ │ │ │ @@ -114,17 +114,17 @@
│ │ │ │     std::map<std::string, std::string> ext_state;
│ │ │ │     libtorrent::ip_filter ip_filter;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    session_params()

    │ │ │ │ 
    │ │ │ │ +session_params ();
│ │ │ │  session_params (settings_pack&& sp);
│ │ │ │  session_params (settings_pack const& sp);
│ │ │ │ -session_params ();
│ │ │ │
    │ │ │ │

    This constructor can be used to start with the default plugins │ │ │ │ (ut_metadata, ut_pex and smart_ban). Pass a settings_pack to set the │ │ │ │ initial settings when the session starts.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    session_params()

    │ │ │ │ @@ -178,33 +178,33 @@ │ │ │ │ synchronize the completion of the shutdown. The lifetime of this object │ │ │ │ may outlive session, causing the session destructor to not block. The │ │ │ │ session_proxy destructor will block however, until the underlying session │ │ │ │ is done shutting down.

    │ │ │ │ 
    │ │ │ │  struct session_proxy
│ │ │ │  {
│ │ │ │ +   session_proxy ();
│ │ │ │     session_proxy (session_proxy const&);
│ │ │ │     session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │     ~session_proxy ();
│ │ │ │ -   session_proxy ();
│ │ │ │ -   session_proxy (session_proxy&&) noexcept;
│ │ │ │     session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +   session_proxy (session_proxy&&) noexcept;
│ │ │ │  };
│ │ │ │
    │ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -

    ~session_proxy() session_proxy() operator=()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +

    session_proxy() operator=() ~session_proxy()

    │ │ │ │ 
    │ │ │ │ +session_proxy ();
│ │ │ │  session_proxy (session_proxy const&);
│ │ │ │  session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │  ~session_proxy ();
│ │ │ │ -session_proxy ();
│ │ │ │ -session_proxy (session_proxy&&) noexcept;
│ │ │ │  session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +session_proxy (session_proxy&&) noexcept;
│ │ │ │
    │ │ │ │

    default constructor, does not refer to any session │ │ │ │ implementation object.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │
    │ │ │ │

    session

    │ │ │ │ @@ -218,52 +218,52 @@ │ │ │ │ session_handle::apply_settings() member function. To change one or more │ │ │ │ configuration options, create a settings_pack. object and fill it with │ │ │ │ the settings to be set and pass it in to session::apply_settings().

    │ │ │ │

    see apply_settings().

    │ │ │ │ 
    │ │ │ │  struct session : session_handle
│ │ │ │  {
│ │ │ │ -   session (session_params const& params, session_flags_t flags);
│ │ │ │     session (session_params&& params, session_flags_t flags);
│ │ │ │     explicit session (session_params const& params);
│ │ │ │ -   session ();
│ │ │ │     explicit session (session_params&& params);
│ │ │ │ -   session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +   session (session_params const& params, session_flags_t flags);
│ │ │ │ +   session ();
│ │ │ │ +   session (session_params const& params, io_context& ios);
│ │ │ │     session (session_params&& params, io_context& ios);
│ │ │ │     session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ -   session (session_params const& params, io_context& ios);
│ │ │ │ +   session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │     ~session ();
│ │ │ │     session_proxy abort ();
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    session()

    │ │ │ │ 
    │ │ │ │ -session (session_params const& params, session_flags_t flags);
│ │ │ │  session (session_params&& params, session_flags_t flags);
│ │ │ │  explicit session (session_params const& params);
│ │ │ │ -session ();
│ │ │ │  explicit session (session_params&& params);
│ │ │ │ +session (session_params const& params, session_flags_t flags);
│ │ │ │ +session ();
│ │ │ │
    │ │ │ │

    Constructs the session objects which acts as the container of torrents. │ │ │ │ In order to avoid a race condition between starting the session and │ │ │ │ configuring it, you can pass in a session_params object. Its settings │ │ │ │ will take effect before the session starts up.

    │ │ │ │

    The overloads taking flags can be used to start a session in │ │ │ │ paused mode (by passing in session::paused). Note that │ │ │ │ add_default_plugins do not have an affect on constructors that │ │ │ │ take a session_params object. It already contains the plugins to use.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    session()

    │ │ │ │ 
    │ │ │ │ -session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params const& params, io_context& ios);
│ │ │ │  session (session_params&& params, io_context& ios);
│ │ │ │  session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ -session (session_params const& params, io_context& ios);
│ │ │ │ +session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │
    │ │ │ │

    Overload of the constructor that takes an external io_context to run │ │ │ │ the session object on. This is primarily useful for tests that may want │ │ │ │ to run multiple sessions on a single io_context, or low resource │ │ │ │ systems where additional threads are expensive and sharing an │ │ │ │ io_context with other events is fine.

    │ │ │ │
    │ │ │ │ @@ -318,35 +318,35 @@ │ │ │ │ any operation on it will throw a system_error exception, with error code │ │ │ │ invalid_session_handle.

    │ │ │ │ 
    │ │ │ │  struct session_handle
│ │ │ │  {
│ │ │ │     bool is_valid () const;
│ │ │ │     session_params session_state (save_state_flags_t flags = save_state_flags_t::all()) const;
│ │ │ │ -   void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ -      , status_flags_t flags = {}) const;
│ │ │ │     std::vector<torrent_status> get_torrent_status (
│ │ │ │        std::function<bool(torrent_status const&)> const& pred
│ │ │ │        , status_flags_t flags = {}) const;
│ │ │ │ +   void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ +      , status_flags_t flags = {}) const;
│ │ │ │     void post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │ │     void post_session_stats ();
│ │ │ │     void post_dht_stats ();
│ │ │ │ -   void set_dht_state (dht::dht_state&& st);
│ │ │ │     void set_dht_state (dht::dht_state const& st);
│ │ │ │ -   std::vector<torrent_handle> get_torrents () const;
│ │ │ │ +   void set_dht_state (dht::dht_state&& st);
│ │ │ │     torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ -   torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +   std::vector<torrent_handle> get_torrents () const;
│ │ │ │     void async_add_torrent (add_torrent_params&& params);
│ │ │ │ +   void async_add_torrent (add_torrent_params const& params);
│ │ │ │     torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ -   torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │     torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ -   void async_add_torrent (add_torrent_params const& params);
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │     void pause ();
│ │ │ │ -   void resume ();
│ │ │ │     bool is_paused () const;
│ │ │ │ +   void resume ();
│ │ │ │     bool is_dht_running () const;
│ │ │ │     void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │     void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ │     void dht_get_item (sha1_hash const& target);
│ │ │ │     void dht_get_item (std::array<char, 32> key
│ │ │ │        , std::string salt = std::string());
│ │ │ │     sha1_hash dht_put_item (entry data);
│ │ │ │ @@ -355,40 +355,40 @@
│ │ │ │        , std::int64_t&, std::string const&)> cb
│ │ │ │        , std::string salt = std::string());
│ │ │ │     void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │     void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │     void dht_live_nodes (sha1_hash const& nid);
│ │ │ │     void dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ │     void dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ │ -   void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ -   void set_ip_filter (ip_filter f);
│ │ │ │ +   void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     ip_filter get_ip_filter () const;
│ │ │ │ +   void set_ip_filter (ip_filter f);
│ │ │ │     void set_port_filter (port_filter const& f);
│ │ │ │     unsigned short ssl_listen_port () const;
│ │ │ │ -   unsigned short listen_port () const;
│ │ │ │     bool is_listening () const;
│ │ │ │ +   unsigned short listen_port () const;
│ │ │ │     void set_peer_class_filter (ip_filter const& f);
│ │ │ │     ip_filter get_peer_class_filter () const;
│ │ │ │ -   void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │     peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ +   void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │     peer_class_t create_peer_class (char const* name);
│ │ │ │     void delete_peer_class (peer_class_t cid);
│ │ │ │ -   peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │     void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ +   peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │     void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │     void apply_settings (settings_pack const&);
│ │ │ │ -   settings_pack get_settings () const;
│ │ │ │     void apply_settings (settings_pack&&);
│ │ │ │ +   settings_pack get_settings () const;
│ │ │ │ +   alert* wait_for_alert (time_duration max_wait);
│ │ │ │     void set_alert_notify (std::function<void()> const& fun);
│ │ │ │     void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ -   alert* wait_for_alert (time_duration max_wait);
│ │ │ │ -   void delete_port_mapping (port_mapping_t handle);
│ │ │ │     std::vector<port_mapping_t> add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │ +   void delete_port_mapping (port_mapping_t handle);
│ │ │ │     void reopen_network_sockets (reopen_network_flags_t options = reopen_map_ports);
│ │ │ │     std::shared_ptr<aux::session_impl> native_handle () const;
│ │ │ │  
│ │ │ │     static constexpr save_state_flags_t save_settings  = 0_bit;
│ │ │ │     static constexpr save_state_flags_t save_dht_state  = 2_bit;
│ │ │ │     static constexpr save_state_flags_t save_extension_state  = 11_bit;
│ │ │ │     static constexpr save_state_flags_t save_ip_filter  = 12_bit;
│ │ │ │ @@ -420,24 +420,24 @@
│ │ │ │  
    returns the current session state. This can be passed to
│ │ │ │  write_session_params() to save the state to disk and restored using
│ │ │ │  read_session_params() when constructing a new session. The kind of
│ │ │ │  state that's included is all settings, the DHT routing table, possibly
│ │ │ │  plugin-specific state.
│ │ │ │  the flags parameter can be used to only save certain parts of the
│ │ │ │  session state
    
│ │ │ │ -
│ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    refresh_torrent_status() get_torrent_status()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    get_torrent_status() refresh_torrent_status()

    │ │ │ │ 
    │ │ │ │ -void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ -      , status_flags_t flags = {}) const;
│ │ │ │  std::vector<torrent_status> get_torrent_status (
│ │ │ │        std::function<bool(torrent_status const&)> const& pred
│ │ │ │        , status_flags_t flags = {}) const;
│ │ │ │ +void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ +      , status_flags_t flags = {}) const;
│ │ │ │
    │ │ │ │
    │ │ │ │

    Note

    │ │ │ │

    these calls are potentially expensive and won't scale well with │ │ │ │ lots of torrents. If you're concerned about performance, consider │ │ │ │ using post_torrent_updates() instead.

    │ │ │ │
    │ │ │ │ @@ -501,47 +501,47 @@ │ │ │ │ void post_dht_stats (); │ │ │ │ │ │ │ │

    This will cause a dht_stats_alert to be posted.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    set_dht_state()

    │ │ │ │ 
    │ │ │ │ -void set_dht_state (dht::dht_state&& st);
│ │ │ │  void set_dht_state (dht::dht_state const& st);
│ │ │ │ +void set_dht_state (dht::dht_state&& st);
│ │ │ │
    │ │ │ │

    set the DHT state for the session. This will be taken into account the │ │ │ │ next time the DHT is started, as if it had been passed in via the │ │ │ │ session_params on startup.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    find_torrent() get_torrents()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    get_torrents() find_torrent()

    │ │ │ │ 
    │ │ │ │ -std::vector<torrent_handle> get_torrents () const;
│ │ │ │  torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ +std::vector<torrent_handle> get_torrents () const;
│ │ │ │
    │ │ │ │

    find_torrent() looks for a torrent with the given info-hash. In │ │ │ │ case there is such a torrent in the session, a torrent_handle to that │ │ │ │ torrent is returned. In case the torrent cannot be found, an invalid │ │ │ │ torrent_handle is returned.

    │ │ │ │

    See torrent_handle::is_valid() to know if the torrent was found or │ │ │ │ not.

    │ │ │ │

    get_torrents() returns a vector of torrent_handles to all the │ │ │ │ torrents currently in the session.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    async_add_torrent() add_torrent()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    add_torrent() async_add_torrent()

    │ │ │ │ 
    │ │ │ │ -torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │  void async_add_torrent (add_torrent_params&& params);
│ │ │ │ +void async_add_torrent (add_torrent_params const& params);
│ │ │ │  torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ -torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │  torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ -void async_add_torrent (add_torrent_params const& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │
    │ │ │ │

    You add torrents through the add_torrent() function where you give an │ │ │ │ object with all the parameters. The add_torrent() overloads will block │ │ │ │ until the torrent has been added (or failed to be added) and returns │ │ │ │ an error code and a torrent_handle. In order to add torrents more │ │ │ │ efficiently, consider using async_add_torrent() which returns │ │ │ │ immediately, without waiting for the torrent to add. Notification of │ │ │ │ @@ -573,16 +573,16 @@ │ │ │ │ │ │ │ │ │ │ │ │ [report issue]

    │ │ │ │
    │ │ │ │

    pause() resume() is_paused()

    │ │ │ │ 
    │ │ │ │  void pause ();
│ │ │ │ -void resume ();
│ │ │ │  bool is_paused () const;
│ │ │ │ +void resume ();
│ │ │ │
    │ │ │ │

    Pausing the session has the same effect as pausing every torrent in │ │ │ │ it, except that torrents will not be resumed by the auto-manage │ │ │ │ mechanism. Resuming will restore the torrents to their previous paused │ │ │ │ state. i.e. the session pause state is separate from the torrent pause │ │ │ │ state. A torrent is inactive if it is paused or if the session is │ │ │ │ paused.

    │ │ │ │ @@ -749,17 +749,17 @@ │ │ │ │ with the response (if any) and the userdata pointer passed in here. │ │ │ │ Since this alert is a response to an explicit call, it will always be │ │ │ │ posted, regardless of the alert mask.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    add_extension()

    │ │ │ │ 
    │ │ │ │ -void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │  void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ +void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │
    │ │ │ │

    This function adds an extension to this session. The argument is a │ │ │ │ function object that is called with a torrent_handle and which should │ │ │ │ return a std::shared_ptr<torrent_plugin>. To write custom │ │ │ │ plugins, see libtorrent plugins. For the typical bittorrent client │ │ │ │ all of these extensions should be added. The main plugins implemented │ │ │ │ in libtorrent are:

    │ │ │ │ @@ -792,16 +792,16 @@ │ │ │ │ ses.add_extension(&lt::create_smart_ban_plugin); │ │ │ │ │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    get_ip_filter() set_ip_filter()

    │ │ │ │ 
    │ │ │ │ -void set_ip_filter (ip_filter f);
│ │ │ │  ip_filter get_ip_filter () const;
│ │ │ │ +void set_ip_filter (ip_filter f);
│ │ │ │
    │ │ │ │

    Sets a filter that will be used to reject and accept incoming as well │ │ │ │ as outgoing connections based on their originating ip address. The │ │ │ │ default filter will allow connections to any ip address. To build a │ │ │ │ set of rules for which addresses are accepted and not, see ip_filter.

    │ │ │ │

    Each time a peer is blocked because of the IP filter, a │ │ │ │ peer_blocked_alert is generated. get_ip_filter() Returns the │ │ │ │ @@ -812,23 +812,23 @@ │ │ │ │ 

    │ │ │ │  void set_port_filter (port_filter const& f);
│ │ │ │
    │ │ │ │

    apply port_filter f to incoming and outgoing peers. a port filter │ │ │ │ will reject making outgoing peer connections to certain remote ports. │ │ │ │ The main intention is to be able to avoid triggering certain │ │ │ │ anti-virus software by connecting to SMTP, FTP ports.

    │ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    ssl_listen_port() listen_port() is_listening()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    listen_port() ssl_listen_port() is_listening()

    │ │ │ │ 
    │ │ │ │  unsigned short ssl_listen_port () const;
│ │ │ │ -unsigned short listen_port () const;
│ │ │ │  bool is_listening () const;
│ │ │ │ +unsigned short listen_port () const;
│ │ │ │
    │ │ │ │

    is_listening() will tell you whether or not the session has │ │ │ │ successfully opened a listening port. If it hasn't, this function will │ │ │ │ return false, and then you can set a new │ │ │ │ settings_pack::listen_interfaces to try another interface and port to │ │ │ │ bind to.

    │ │ │ │

    listen_port() returns the port we ended up listening on.

    │ │ │ │ @@ -862,21 +862,21 @@ │ │ │ │ 32 bits in the IP range mapping. Only the set bits matter; no peer │ │ │ │ class will be removed from a peer as a result of this call, peer │ │ │ │ classes are only added.

    │ │ │ │

    The peer_class argument cannot be greater than 31. The bitmasks │ │ │ │ representing peer classes in the peer_class_filter are 32 bits.

    │ │ │ │

    The get_peer_class_filter() function returns the current filter.

    │ │ │ │

    For more information, see peer classes.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    get_peer_class_type_filter() set_peer_class_type_filter()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    set_peer_class_type_filter() get_peer_class_type_filter()

    │ │ │ │ 
    │ │ │ │ -void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │  peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ +void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │
    │ │ │ │

    Sets and gets the peer class type filter. This is controls automatic │ │ │ │ peer class assignments to peers based on what kind of socket it is.

    │ │ │ │

    It does not only support assigning peer classes, it also supports │ │ │ │ removing peer classes based on socket type.

    │ │ │ │

    The order of these rules being applied are:

    │ │ │ │
      │ │ │ │ @@ -920,16 +920,16 @@ │ │ │ │ destructs.

      │ │ │ │

      For more information on peer classes, see peer classes.

      │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    set_peer_class() get_peer_class()

    │ │ │ │ 
    │ │ │ │ -peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │  void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ +peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │
    │ │ │ │

    These functions queries information from a peer class and updates the │ │ │ │ configuration of a peer class, respectively.

    │ │ │ │

    cid must refer to an existing peer class. If it does not, the │ │ │ │ return value of get_peer_class() is undefined.

    │ │ │ │

    set_peer_class() sets all the information in the │ │ │ │ peer_class_info object in the specified peer class. There is no │ │ │ │ @@ -969,35 +969,35 @@ │ │ │ │ handle.save_resume_data(); │ │ │ │

    Note that when a queued or downloading torrent is removed, its position │ │ │ │ in the download queue is vacated and every subsequent torrent in the │ │ │ │ queue has their queue positions updated. This can potentially cause a │ │ │ │ large state_update to be posted. When removing all torrents, it is │ │ │ │ advised to remove them from the back of the queue, to minimize the │ │ │ │ shifting.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    get_settings() apply_settings()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    apply_settings() get_settings()

    │ │ │ │ 
    │ │ │ │  void apply_settings (settings_pack const&);
│ │ │ │ -settings_pack get_settings () const;
│ │ │ │  void apply_settings (settings_pack&&);
│ │ │ │ +settings_pack get_settings () const;
│ │ │ │
    │ │ │ │

    Applies the settings specified by the settings_pack s. This is an │ │ │ │ asynchronous operation that will return immediately and actually apply │ │ │ │ the settings to the main thread of libtorrent some time later.

    │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    set_alert_notify() pop_alerts() wait_for_alert()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    set_alert_notify() wait_for_alert() pop_alerts()

    │ │ │ │ 
    │ │ │ │ +alert* wait_for_alert (time_duration max_wait);
│ │ │ │  void set_alert_notify (std::function<void()> const& fun);
│ │ │ │  void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ -alert* wait_for_alert (time_duration max_wait);
│ │ │ │
    │ │ │ │

    Alerts is the main mechanism for libtorrent to report errors and │ │ │ │ events. pop_alerts fills in the vector passed to it with pointers │ │ │ │ to new alerts. The session still owns these alerts and they will stay │ │ │ │ valid until the next time pop_alerts is called. You may not delete │ │ │ │ the alert objects.

    │ │ │ │

    It is safe to call pop_alerts from multiple different threads, as │ │ │ │ @@ -1048,16 +1048,16 @@ │ │ │ │ alert::type() but can also be queries from a concrete type via │ │ │ │ T::alert_type, as a static constant.

    │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    delete_port_mapping() add_port_mapping()

    │ │ │ │ 
    │ │ │ │ -void delete_port_mapping (port_mapping_t handle);
│ │ │ │  std::vector<port_mapping_t> add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │ +void delete_port_mapping (port_mapping_t handle);
│ │ │ │
    │ │ │ │

    add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP, │ │ │ │ whichever is enabled. A mapping is created for each listen socket │ │ │ │ in the session. The return values are all handles referring to the │ │ │ │ port mappings that were just created. Pass them to delete_port_mapping() │ │ │ │ to remove them.

    │ │ │ │ [report issue]
    │ │ │ │ @@ -1123,30 +1123,30 @@ │ │ │ │ [report issue]
    │ │ │ │
    reopen_map_ports
    │ │ │ │
    This option indicates if the ports are mapped using natpmp │ │ │ │ and upnp. If mapping was already made, they are deleted and added │ │ │ │ again. This only works if natpmp and/or upnp are configured to be │ │ │ │ enable.
    │ │ │ │
    │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ +[report issue]
    │ │ │ │
    │ │ │ │ -
    │ │ │ │ -

    write_session_params_buf() read_session_params() write_session_params()

    │ │ │ │ +
    │ │ │ │ +

    write_session_params() read_session_params() write_session_params_buf()

    │ │ │ │

    Declared in "libtorrent/session_params.hpp"

    │ │ │ │ 
    │ │ │ │ -entry write_session_params (session_params const& sp
│ │ │ │ +session_params read_session_params (bdecode_node const& e
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ -session_params read_session_params (bdecode_node const& e
│ │ │ │ -   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  session_params read_session_params (span<char const> buf
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +entry write_session_params (session_params const& sp
│ │ │ │ +   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │
    │ │ │ │

    These functions serialize and de-serialize a session_params object to and │ │ │ │ from bencoded form. The session_params object is used to initialize a new │ │ │ │ session using the state from a previous one (or by programmatically configure │ │ │ │ the session up-front). │ │ │ │ The flags parameter can be used to only save and load certain aspects of the │ │ │ │ session's state. │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -3,30 +3,30 @@ │ │ │ │ │ VVeerrssiioonn:: 2.0.11 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _s_e_s_s_i_o_n___p_a_r_a_m_s │ │ │ │ │ o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ * _s_e_s_s_i_o_n___p_r_o_x_y │ │ │ │ │ - o _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_) │ │ │ │ │ + o _s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_s_e_s_s_i_o_n___p_r_o_x_y_(_) │ │ │ │ │ * _s_e_s_s_i_o_n │ │ │ │ │ o _s_e_s_s_i_o_n_(_) │ │ │ │ │ o _s_e_s_s_i_o_n_(_) │ │ │ │ │ o _~_s_e_s_s_i_o_n_(_) │ │ │ │ │ o _a_b_o_r_t_(_) │ │ │ │ │ * _s_e_s_s_i_o_n___h_a_n_d_l_e │ │ │ │ │ o _i_s___v_a_l_i_d_(_) │ │ │ │ │ o _s_e_s_s_i_o_n___s_t_a_t_e_(_) │ │ │ │ │ - o _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_) │ │ │ │ │ + o _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_) │ │ │ │ │ o _p_o_s_t___t_o_r_r_e_n_t___u_p_d_a_t_e_s_(_) │ │ │ │ │ o _p_o_s_t___s_e_s_s_i_o_n___s_t_a_t_s_(_) │ │ │ │ │ o _p_o_s_t___d_h_t___s_t_a_t_s_(_) │ │ │ │ │ o _s_e_t___d_h_t___s_t_a_t_e_(_) │ │ │ │ │ - o _f_i_n_d___t_o_r_r_e_n_t_(_)_ _g_e_t___t_o_r_r_e_n_t_s_(_) │ │ │ │ │ - o _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)_ _a_d_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ + o _g_e_t___t_o_r_r_e_n_t_s_(_)_ _f_i_n_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ + o _a_d_d___t_o_r_r_e_n_t_(_)_ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_) │ │ │ │ │ o _i_s___d_h_t___r_u_n_n_i_n_g_(_) │ │ │ │ │ o _s_e_t___d_h_t___s_t_o_r_a_g_e_(_) │ │ │ │ │ o _a_d_d___d_h_t___n_o_d_e_(_) │ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_) │ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_) │ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_) │ │ │ │ │ @@ -34,37 +34,37 @@ │ │ │ │ │ o _d_h_t___g_e_t___p_e_e_r_s_(_)_ _d_h_t___a_n_n_o_u_n_c_e_(_) │ │ │ │ │ o _d_h_t___l_i_v_e___n_o_d_e_s_(_) │ │ │ │ │ o _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s_(_) │ │ │ │ │ o _d_h_t___d_i_r_e_c_t___r_e_q_u_e_s_t_(_) │ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_) │ │ │ │ │ o _g_e_t___i_p___f_i_l_t_e_r_(_)_ _s_e_t___i_p___f_i_l_t_e_r_(_) │ │ │ │ │ o _s_e_t___p_o_r_t___f_i_l_t_e_r_(_) │ │ │ │ │ - o _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_) │ │ │ │ │ + o _l_i_s_t_e_n___p_o_r_t_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_) │ │ │ │ │ o _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_) │ │ │ │ │ - o _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_) │ │ │ │ │ + o _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_) │ │ │ │ │ o _c_r_e_a_t_e___p_e_e_r___c_l_a_s_s_(_) │ │ │ │ │ o _d_e_l_e_t_e___p_e_e_r___c_l_a_s_s_(_) │ │ │ │ │ o _s_e_t___p_e_e_r___c_l_a_s_s_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s_(_) │ │ │ │ │ o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_) │ │ │ │ │ - o _g_e_t___s_e_t_t_i_n_g_s_(_)_ _a_p_p_l_y___s_e_t_t_i_n_g_s_(_) │ │ │ │ │ - o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _p_o_p___a_l_e_r_t_s_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_) │ │ │ │ │ + o _a_p_p_l_y___s_e_t_t_i_n_g_s_(_)_ _g_e_t___s_e_t_t_i_n_g_s_(_) │ │ │ │ │ + o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)_ _p_o_p___a_l_e_r_t_s_(_) │ │ │ │ │ o _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_)_ _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_) │ │ │ │ │ o _r_e_o_p_e_n___n_e_t_w_o_r_k___s_o_c_k_e_t_s_(_) │ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_) │ │ │ │ │ - * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ + * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseessssiioonn__ppaarraammss ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p" │ │ │ │ │ The _s_e_s_s_i_o_n___p_a_r_a_m_s is a parameters pack for configuring the _s_e_s_s_i_o_n before it's │ │ │ │ │ started. │ │ │ │ │ struct session_params │ │ │ │ │ { │ │ │ │ │ + sseessssiioonn__ppaarraammss (); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp); │ │ │ │ │ - sseessssiioonn__ppaarraammss (); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ │ │ │ │ │ settings_pack settings; │ │ │ │ │ std::vector> extensions; │ │ │ │ │ @@ -72,17 +72,17 @@ │ │ │ │ │ dht::dht_storage_constructor_type dht_storage_constructor; │ │ │ │ │ disk_io_constructor_type disk_io_constructor; │ │ │ │ │ std::map ext_state; │ │ │ │ │ libtorrent::ip_filter ip_filter; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) ********** │ │ │ │ │ +sseessssiioonn__ppaarraammss (); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp); │ │ │ │ │ -sseessssiioonn__ppaarraammss (); │ │ │ │ │ This constructor can be used to start with the default plugins (ut_metadata, │ │ │ │ │ ut_pex and smart_ban). Pass a _s_e_t_t_i_n_g_s___p_a_c_k to set the initial settings when │ │ │ │ │ the _s_e_s_s_i_o_n starts. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) ********** │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ @@ -122,29 +122,29 @@ │ │ │ │ │ _s_e_s_s_i_o_n destruction is explicitly initiated, this holder is used to synchronize │ │ │ │ │ the completion of the shutdown. The lifetime of this object may outlive │ │ │ │ │ _s_e_s_s_i_o_n, causing the _s_e_s_s_i_o_n destructor to not block. The _s_e_s_s_i_o_n___p_r_o_x_y │ │ │ │ │ destructor will block however, until the underlying _s_e_s_s_i_o_n is done shutting │ │ │ │ │ down. │ │ │ │ │ struct session_proxy │ │ │ │ │ { │ │ │ │ │ + sseessssiioonn__pprrooxxyy (); │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&); │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ ~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ - sseessssiioonn__pprrooxxyy (); │ │ │ │ │ - sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ + sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ~~sseessssiioonn__pprrooxxyy(()) sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ +********** sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) ~~sseessssiioonn__pprrooxxyy(()) ********** │ │ │ │ │ +sseessssiioonn__pprrooxxyy (); │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&); │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ ~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ -sseessssiioonn__pprrooxxyy (); │ │ │ │ │ -sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ +sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ default constructor, does not refer to any _s_e_s_s_i_o_n implementation object. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseessssiioonn ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p" │ │ │ │ │ The _s_e_s_s_i_o_n holds all state that spans multiple torrents. Among other things it │ │ │ │ │ runs the network loop and manages all torrents. Once it's created, the _s_e_s_s_i_o_n │ │ │ │ │ object will spawn the main thread that will do all the work. The main thread │ │ │ │ │ @@ -152,47 +152,47 @@ │ │ │ │ │ You have some control over _s_e_s_s_i_o_n configuration through the session_handle:: │ │ │ │ │ apply_settings() member function. To change one or more configuration options, │ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k. object and fill it with the settings to be set and pass │ │ │ │ │ it in to session::apply_settings(). │ │ │ │ │ see _a_p_p_l_y___s_e_t_t_i_n_g_s_(_). │ │ │ │ │ struct session : session_handle │ │ │ │ │ { │ │ │ │ │ - sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ explicit sseessssiioonn (session_params const& params); │ │ │ │ │ - sseessssiioonn (); │ │ │ │ │ explicit sseessssiioonn (session_params&& params); │ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ + sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ + sseessssiioonn (); │ │ │ │ │ + sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t); │ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ + sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ ~~sseessssiioonn (); │ │ │ │ │ session_proxy aabboorrtt (); │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn(()) ********** │ │ │ │ │ -sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ explicit sseessssiioonn (session_params const& params); │ │ │ │ │ -sseessssiioonn (); │ │ │ │ │ explicit sseessssiioonn (session_params&& params); │ │ │ │ │ +sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ +sseessssiioonn (); │ │ │ │ │ Constructs the _s_e_s_s_i_o_n objects which acts as the container of torrents. In │ │ │ │ │ order to avoid a race condition between starting the _s_e_s_s_i_o_n and configuring │ │ │ │ │ it, you can pass in a _s_e_s_s_i_o_n___p_a_r_a_m_s object. Its settings will take effect │ │ │ │ │ before the _s_e_s_s_i_o_n starts up. │ │ │ │ │ The overloads taking flags can be used to start a _s_e_s_s_i_o_n in paused mode (by │ │ │ │ │ passing in session::paused). Note that add_default_plugins do not have an │ │ │ │ │ affect on constructors that take a _s_e_s_s_i_o_n___p_a_r_a_m_s object. It already contains │ │ │ │ │ the plugins to use. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn(()) ********** │ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t); │ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ Overload of the constructor that takes an external io_context to run the │ │ │ │ │ _s_e_s_s_i_o_n object on. This is primarily useful for tests that may want to run │ │ │ │ │ multiple sessions on a single io_context, or low resource systems where │ │ │ │ │ additional threads are expensive and sharing an io_context with other events is │ │ │ │ │ fine. │ │ │ │ │ Warning │ │ │ │ │ The _s_e_s_s_i_o_n object does not cleanly terminate with an external io_context. The │ │ │ │ │ @@ -232,36 +232,36 @@ │ │ │ │ │ operation on it will throw a system_error exception, with error code │ │ │ │ │ invalid_session_handle. │ │ │ │ │ struct session_handle │ │ │ │ │ { │ │ │ │ │ bool iiss__vvaalliidd () const; │ │ │ │ │ session_params sseessssiioonn__ssttaattee (save_state_flags_t flags = │ │ │ │ │ save_state_flags_t::all()) const; │ │ │ │ │ - void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret │ │ │ │ │ - , status_flags_t flags = {}) const; │ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss ( │ │ │ │ │ std::function const& pred │ │ │ │ │ , status_flags_t flags = {}) const; │ │ │ │ │ + void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret │ │ │ │ │ + , status_flags_t flags = {}) const; │ │ │ │ │ void ppoosstt__ttoorrrreenntt__uuppddaatteess (status_flags_t flags = status_flags_t::all()); │ │ │ │ │ void ppoosstt__sseessssiioonn__ssttaattss (); │ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss (); │ │ │ │ │ - void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ - std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ + void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ + std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec); │ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& │ │ │ │ │ ec); │ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ void ppaauussee (); │ │ │ │ │ - void rreessuummee (); │ │ │ │ │ bool iiss__ppaauusseedd () const; │ │ │ │ │ + void rreessuummee (); │ │ │ │ │ bool iiss__ddhhtt__rruunnnniinngg () const; │ │ │ │ │ void sseett__ddhhtt__ssttoorraaggee (dht::dht_storage_constructor_type sc); │ │ │ │ │ void aadddd__ddhhtt__nnooddee (std::pair const& node); │ │ │ │ │ void ddhhtt__ggeett__iitteemm (sha1_hash const& target); │ │ │ │ │ void ddhhtt__ggeett__iitteemm (std::array key │ │ │ │ │ , std::string salt = std::string()); │ │ │ │ │ sha1_hash ddhhtt__ppuutt__iitteemm (entry data); │ │ │ │ │ @@ -273,41 +273,41 @@ │ │ │ │ │ announce_flags_t flags = {}); │ │ │ │ │ void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash); │ │ │ │ │ void ddhhtt__lliivvee__nnooddeess (sha1_hash const& nid); │ │ │ │ │ void ddhhtt__ssaammppllee__iinnffoohhaasshheess (udp::endpoint const& ep, sha1_hash const& │ │ │ │ │ target); │ │ │ │ │ void ddhhtt__ddiirreecctt__rreeqquueesstt (udp::endpoint const& ep, entry const& e, │ │ │ │ │ client_data_t userdata = {}); │ │ │ │ │ - void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function( │ │ │ │ │ torrent_handle const&, client_data_t)> ext); │ │ │ │ │ - void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ + void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ + void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f); │ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ - unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ bool iiss__lliisstteenniinngg () const; │ │ │ │ │ + unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f); │ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const; │ │ │ │ │ - void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f); │ │ │ │ │ peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const; │ │ │ │ │ + void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f); │ │ │ │ │ peer_class_t ccrreeaattee__ppeeeerr__ccllaassss (char const* name); │ │ │ │ │ void ddeelleettee__ppeeeerr__ccllaassss (peer_class_t cid); │ │ │ │ │ - peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const; │ │ │ │ │ void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ + peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const; │ │ │ │ │ void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {}); │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ - settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ + settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ + alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ - alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ - void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int │ │ │ │ │ external_port, int local_port); │ │ │ │ │ + void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options = │ │ │ │ │ reopen_map_ports); │ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const; │ │ │ │ │ │ │ │ │ │ static constexpr save_state_flags_t ssaavvee__sseettttiinnggss = 0_bit; │ │ │ │ │ static constexpr save_state_flags_t ssaavvee__ddhhtt__ssttaattee = 2_bit; │ │ │ │ │ static constexpr save_state_flags_t ssaavvee__eexxtteennssiioonn__ssttaattee = 11_bit; │ │ │ │ │ @@ -333,20 +333,20 @@ │ │ │ │ │ all()) const; │ │ │ │ │ returns the current _s_e_s_s_i_o_n state. This can be passed to _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ to save the state to disk and restored using _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) when │ │ │ │ │ constructing a new _s_e_s_s_i_o_n. The kind of state that's included is all settings, │ │ │ │ │ the DHT routing table, possibly plugin-specific state. the flags parameter can │ │ │ │ │ be used to only save certain parts of the _s_e_s_s_i_o_n state │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__ttoorrrreenntt__ssttaattuuss(()) ********** │ │ │ │ │ -void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret │ │ │ │ │ - , status_flags_t flags = {}) const; │ │ │ │ │ +********** ggeett__ttoorrrreenntt__ssttaattuuss(()) rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ********** │ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss ( │ │ │ │ │ std::function const& pred │ │ │ │ │ , status_flags_t flags = {}) const; │ │ │ │ │ +void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret │ │ │ │ │ + , status_flags_t flags = {}) const; │ │ │ │ │ Note │ │ │ │ │ these calls are potentially expensive and won't scale well with lots of │ │ │ │ │ torrents. If you're concerned about performance, consider using │ │ │ │ │ post_torrent_updates() instead. │ │ │ │ │ get_torrent_status returns a vector of the _t_o_r_r_e_n_t___s_t_a_t_u_s for every torrent │ │ │ │ │ which satisfies pred, which is a predicate function which determines if a │ │ │ │ │ torrent should be included in the returned set or not. Returning true means it │ │ │ │ │ @@ -391,37 +391,37 @@ │ │ │ │ │ For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ppoosstt__ddhhtt__ssttaattss(()) ********** │ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss (); │ │ │ │ │ This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) ********** │ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next │ │ │ │ │ time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on │ │ │ │ │ startup. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ffiinndd__ttoorrrreenntt(()) ggeett__ttoorrrreennttss(()) ********** │ │ │ │ │ -std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ +********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) ********** │ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ +std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ find_torrent() looks for a torrent with the given info-hash. In case there is │ │ │ │ │ such a torrent in the _s_e_s_s_i_o_n, a _t_o_r_r_e_n_t___h_a_n_d_l_e to that torrent is returned. In │ │ │ │ │ case the torrent cannot be found, an invalid _t_o_r_r_e_n_t___h_a_n_d_l_e is returned. │ │ │ │ │ See torrent_handle::is_valid() to know if the torrent was found or not. │ │ │ │ │ get_torrents() returns a vector of torrent_handles to all the torrents │ │ │ │ │ currently in the _s_e_s_s_i_o_n. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** aassyynncc__aadddd__ttoorrrreenntt(()) aadddd__ttoorrrreenntt(()) ********** │ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ +********** aadddd__ttoorrrreenntt(()) aassyynncc__aadddd__ttoorrrreenntt(()) ********** │ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec); │ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec); │ │ │ │ │ You add torrents through the _a_d_d___t_o_r_r_e_n_t_(_) function where you give an object │ │ │ │ │ with all the parameters. The _a_d_d___t_o_r_r_e_n_t_(_) overloads will block until the │ │ │ │ │ torrent has been added (or failed to be added) and returns an error code and a │ │ │ │ │ _t_o_r_r_e_n_t___h_a_n_d_l_e. In order to add torrents more efficiently, consider using │ │ │ │ │ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) which returns immediately, without waiting for the torrent │ │ │ │ │ to add. Notification of the torrent being added is sent as _a_d_d___t_o_r_r_e_n_t___a_l_e_r_t. │ │ │ │ │ The save_path field in _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s must be set to a valid path where the │ │ │ │ │ @@ -444,16 +444,16 @@ │ │ │ │ │ torrent_flags::upload_mode flag. │ │ │ │ │ Special consideration has to be taken when adding hybrid torrents (i.e. │ │ │ │ │ torrents that are BitTorrent v2 torrents that are backwards compatible with │ │ │ │ │ v1). For more details, see _B_i_t_T_o_r_r_e_n_t_ _v_2_ _t_o_r_r_e_n_t_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ppaauussee(()) rreessuummee(()) iiss__ppaauusseedd(()) ********** │ │ │ │ │ void ppaauussee (); │ │ │ │ │ -void rreessuummee (); │ │ │ │ │ bool iiss__ppaauusseedd () const; │ │ │ │ │ +void rreessuummee (); │ │ │ │ │ Pausing the _s_e_s_s_i_o_n has the same effect as pausing every torrent in it, except │ │ │ │ │ that torrents will not be resumed by the auto-manage mechanism. Resuming will │ │ │ │ │ restore the torrents to their previous paused state. i.e. the _s_e_s_s_i_o_n pause │ │ │ │ │ state is separate from the torrent pause state. A torrent is inactive if it is │ │ │ │ │ paused or if the _s_e_s_s_i_o_n is paused. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** iiss__ddhhtt__rruunnnniinngg(()) ********** │ │ │ │ │ @@ -572,17 +572,17 @@ │ │ │ │ │ Send an arbitrary DHT request directly to the specified endpoint. This function │ │ │ │ │ is intended for use by plugins. When a response is received or the request │ │ │ │ │ times out, a _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t will be posted with the response (if │ │ │ │ │ any) and the userdata pointer passed in here. Since this _a_l_e_r_t is a response to │ │ │ │ │ an explicit call, it will always be posted, regardless of the _a_l_e_r_t mask. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aadddd__eexxtteennssiioonn(()) ********** │ │ │ │ │ -void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function( │ │ │ │ │ torrent_handle const&, client_data_t)> ext); │ │ │ │ │ +void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ This function adds an extension to this _s_e_s_s_i_o_n. The argument is a function │ │ │ │ │ object that is called with a torrent_handle and which should return a std:: │ │ │ │ │ shared_ptr. To write custom plugins, see _l_i_b_t_o_r_r_e_n_t_ _p_l_u_g_i_n_s. │ │ │ │ │ For the typical bittorrent client all of these extensions should be added. The │ │ │ │ │ main plugins implemented in libtorrent are: │ │ │ │ │ uTorrent metadata │ │ │ │ │ Allows peers to download the metadata (.torrent files) from the swarm │ │ │ │ │ @@ -598,16 +598,16 @@ │ │ │ │ │ A _p_l_u_g_i_n that, with a small overhead, can ban peers that sends bad data │ │ │ │ │ with very high accuracy. Should eliminate most problems on poisoned │ │ │ │ │ torrents. │ │ │ │ │ #include │ │ │ │ │ ses.add_extension(<::create_smart_ban_plugin); │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ggeett__iipp__ffiilltteerr(()) sseett__iipp__ffiilltteerr(()) ********** │ │ │ │ │ -void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ +void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ Sets a filter that will be used to reject and accept incoming as well as │ │ │ │ │ outgoing connections based on their originating ip address. The default filter │ │ │ │ │ will allow connections to any ip address. To build a set of rules for which │ │ │ │ │ addresses are accepted and not, see _i_p___f_i_l_t_e_r. │ │ │ │ │ Each time a peer is blocked because of the IP filter, a _p_e_e_r___b_l_o_c_k_e_d___a_l_e_r_t is │ │ │ │ │ generated. get_ip_filter() Returns the _i_p___f_i_l_t_e_r currently in the _s_e_s_s_i_o_n. See │ │ │ │ │ _i_p___f_i_l_t_e_r. │ │ │ │ │ @@ -615,18 +615,18 @@ │ │ │ │ │ ********** sseett__ppoorrtt__ffiilltteerr(()) ********** │ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f); │ │ │ │ │ apply _p_o_r_t___f_i_l_t_e_r f to incoming and outgoing peers. a port filter will reject │ │ │ │ │ making outgoing peer connections to certain remote ports. The main intention is │ │ │ │ │ to be able to avoid triggering certain anti-virus software by connecting to │ │ │ │ │ SMTP, FTP ports. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ssssll__lliisstteenn__ppoorrtt(()) lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) ********** │ │ │ │ │ +********** lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) ********** │ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ -unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ bool iiss__lliisstteenniinngg () const; │ │ │ │ │ +unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ is_listening() will tell you whether or not the _s_e_s_s_i_o_n has successfully opened │ │ │ │ │ a listening port. If it hasn't, this function will return false, and then you │ │ │ │ │ can set a new _s_e_t_t_i_n_g_s___p_a_c_k_:_:_l_i_s_t_e_n___i_n_t_e_r_f_a_c_e_s to try another interface and │ │ │ │ │ port to bind to. │ │ │ │ │ listen_port() returns the port we ended up listening on. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) ********** │ │ │ │ │ @@ -652,17 +652,17 @@ │ │ │ │ │ in the IP range mapping. Only the set bits matter; no peer class will be │ │ │ │ │ removed from a peer as a result of this call, peer classes are only added. │ │ │ │ │ The peer_class argument cannot be greater than 31. The bitmasks representing │ │ │ │ │ peer classes in the peer_class_filter are 32 bits. │ │ │ │ │ The get_peer_class_filter() function returns the current filter. │ │ │ │ │ For more information, see _p_e_e_r_ _c_l_a_s_s_e_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ********** │ │ │ │ │ -void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f); │ │ │ │ │ +********** sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ********** │ │ │ │ │ peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const; │ │ │ │ │ +void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f); │ │ │ │ │ Sets and gets the ppeeeerr ccllaassss ttyyppee ffiilltteerr. This is controls automatic peer class │ │ │ │ │ assignments to peers based on what kind of socket it is. │ │ │ │ │ It does not only support assigning peer classes, it also supports removing peer │ │ │ │ │ classes based on socket type. │ │ │ │ │ The order of these rules being applied are: │ │ │ │ │ 1. peer-class IP filter │ │ │ │ │ 2. peer-class type filter, removing classes │ │ │ │ │ @@ -691,16 +691,16 @@ │ │ │ │ │ peer class if it's still assigned to torrents or peers. It will however remove │ │ │ │ │ it once the last peer and torrent drops their references to it. │ │ │ │ │ There is no need to call this function for custom peer classes. All peer │ │ │ │ │ classes will be properly destructed when the _s_e_s_s_i_o_n object destructs. │ │ │ │ │ For more information on peer classes, see _p_e_e_r_ _c_l_a_s_s_e_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseett__ppeeeerr__ccllaassss(()) ggeett__ppeeeerr__ccllaassss(()) ********** │ │ │ │ │ -peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const; │ │ │ │ │ void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ +peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const; │ │ │ │ │ These functions queries information from a peer class and updates the │ │ │ │ │ configuration of a peer class, respectively. │ │ │ │ │ cid must refer to an existing peer class. If it does not, the return value of │ │ │ │ │ get_peer_class() is undefined. │ │ │ │ │ set_peer_class() sets all the information in the _p_e_e_r___c_l_a_s_s___i_n_f_o object in the │ │ │ │ │ specified peer class. There is no option to only update a single property. │ │ │ │ │ A peer or torrent belonging to more than one class, the highest priority among │ │ │ │ │ @@ -730,26 +730,26 @@ │ │ │ │ │ session.remove_handle(handle); handle.save_resume_data(); │ │ │ │ │ Note that when a queued or downloading torrent is removed, its position in the │ │ │ │ │ download queue is vacated and every subsequent torrent in the queue has their │ │ │ │ │ queue positions updated. This can potentially cause a large state_update to be │ │ │ │ │ posted. When removing all torrents, it is advised to remove them from the back │ │ │ │ │ of the queue, to minimize the shifting. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ggeett__sseettttiinnggss(()) aappppllyy__sseettttiinnggss(()) ********** │ │ │ │ │ +********** aappppllyy__sseettttiinnggss(()) ggeett__sseettttiinnggss(()) ********** │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ -settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ +settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous │ │ │ │ │ operation that will return immediately and actually apply the settings to the │ │ │ │ │ main thread of libtorrent some time later. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__aalleerrtt__nnoottiiffyy(()) ppoopp__aalleerrttss(()) wwaaiitt__ffoorr__aalleerrtt(()) ********** │ │ │ │ │ +********** sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) ppoopp__aalleerrttss(()) ********** │ │ │ │ │ +alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ -alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ Alerts is the main mechanism for libtorrent to report errors and events. │ │ │ │ │ pop_alerts fills in the vector passed to it with pointers to new alerts. The │ │ │ │ │ _s_e_s_s_i_o_n still owns these alerts and they will stay valid until the next time │ │ │ │ │ pop_alerts is called. You may not delete the _a_l_e_r_t objects. │ │ │ │ │ It is safe to call pop_alerts from multiple different threads, as long as the │ │ │ │ │ alerts themselves are not accessed once another thread calls pop_alerts. Doing │ │ │ │ │ this requires manual synchronization between the popping threads. │ │ │ │ │ @@ -789,17 +789,17 @@ │ │ │ │ │ block. It should not perform any expensive work. It really should just notify │ │ │ │ │ the main application thread. │ │ │ │ │ The type of an _a_l_e_r_t is returned by the polymorphic function alert::type() but │ │ │ │ │ can also be queries from a concrete type via T::alert_type, as a static │ │ │ │ │ constant. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ddeelleettee__ppoorrtt__mmaappppiinngg(()) aadddd__ppoorrtt__mmaappppiinngg(()) ********** │ │ │ │ │ -void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int │ │ │ │ │ external_port, int local_port); │ │ │ │ │ +void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP, │ │ │ │ │ whichever is enabled. A mapping is created for each listen socket in the │ │ │ │ │ _s_e_s_s_i_o_n. The return values are all handles referring to the port mappings that │ │ │ │ │ were just created. Pass them to _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_) to remove them. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** rreeooppeenn__nneettwwoorrkk__ssoocckkeettss(()) ********** │ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options = │ │ │ │ │ @@ -845,25 +845,25 @@ │ │ │ │ │ protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ reopen_map_ports │ │ │ │ │ This option indicates if the ports are mapped using natpmp and upnp. If │ │ │ │ │ mapping was already made, they are deleted and added again. This only │ │ │ │ │ works if natpmp and/or upnp are configured to be enable. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss(()) │ │ │ │ │ +************ wwrriittee__sseessssiioonn__ppaarraammss(()) rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) │ │ │ │ │ ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p" │ │ │ │ │ -entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp │ │ │ │ │ +session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e │ │ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ +entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp │ │ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ These functions serialize and de-serialize a session_params object to and from │ │ │ │ │ bencoded form. The _s_e_s_s_i_o_n___p_a_r_a_m_s object is used to initialize a new _s_e_s_s_i_o_n │ │ │ │ │ using the state from a previous one (or by programmatically configure the │ │ │ │ │ _s_e_s_s_i_o_n up-front). The flags parameter can be used to only save and load │ │ │ │ │ certain aspects of the session's state. The _buf suffix indicates the function │ │ │ │ │ operates on buffer rather than the bencoded structure. The torrents in a │ │ │ │ │ _s_e_s_s_i_o_n are not part of the _s_e_s_s_i_o_n___p_a_r_a_m_s state, they have to be restored │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Settings.html │ │ │ │ @@ -29,15 +29,15 @@ │ │ │ │ │ │ │ │ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │ │ │ │ │
    │ │ │ │

    You have some control over session configuration through the session::apply_settings() │ │ │ │ member function. To change one or more configuration options, create a settings_pack │ │ │ │ object and fill it with the settings to be set and pass it in to session::apply_settings().

    │ │ │ │

    The settings_pack object is a collection of settings updates that are applied │ │ │ │ @@ -4598,18 +4598,18 @@ │ │ │ │

    │ │ │ │ 
    │ │ │ │  struct settings_pack final : settings_interface
│ │ │ │  {
│ │ │ │     friend  void apply_pack_impl (settings_pack const*
│ │ │ │        , aux::session_settings_single_thread&
│ │ │ │        , std::vector<void(aux::session_impl::*)()>*);
│ │ │ │ -   void set_int (int name, int val) override;
│ │ │ │ +   void set_str (int name, std::string val) override;
│ │ │ │     void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +   void set_int (int name, int val) override;
│ │ │ │     void set_bool (int name, bool val) override;
│ │ │ │ -   void set_str (int name, std::string val) override;
│ │ │ │     bool has_val (int name) const override;
│ │ │ │     void clear ();
│ │ │ │     void clear (int name);
│ │ │ │     int get_int (int name) const override;
│ │ │ │     bool get_bool (int name) const override;
│ │ │ │     std::string const& get_str (int name) const override;
│ │ │ │     void for_each (Fun&& f) const;
│ │ │ │ @@ -4685,23 +4685,23 @@
│ │ │ │        socks5,
│ │ │ │        socks5_pw,
│ │ │ │        http,
│ │ │ │        http_pw,
│ │ │ │     };
│ │ │ │  };
│ │ │ │
    │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -

    set_bool() set_int() set_str()

    │ │ │ │ +[report issue]
    │ │ │ │ +

    set_str() set_bool() set_int()

    │ │ │ │ 
    │ │ │ │ -void set_int (int name, int val) override;
│ │ │ │ +void set_str (int name, std::string val) override;
│ │ │ │  void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +void set_int (int name, int val) override;
│ │ │ │  void set_bool (int name, bool val) override;
│ │ │ │ -void set_str (int name, std::string val) override;
│ │ │ │
    │ │ │ │

    set a configuration option in the settings_pack. name is one of │ │ │ │ the enum values from string_types, int_types or bool_types. They must │ │ │ │ match the respective type of the set_* function.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    has_val()

    │ │ │ │ @@ -5160,16 +5160,16 @@ │ │ │ │ identify the version of your client.

    │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    min_memory_usage() high_performance_seed()

    │ │ │ │

    Declared in "libtorrent/session.hpp"

    │ │ │ │ 
    │ │ │ │ -settings_pack min_memory_usage ();
│ │ │ │  settings_pack high_performance_seed ();
│ │ │ │ +settings_pack min_memory_usage ();
│ │ │ │
    │ │ │ │

    The default values of the session settings are set for a regular │ │ │ │ bittorrent client running on a desktop system. There are functions that │ │ │ │ can set the session settings to pre set settings for other environments. │ │ │ │ These can be used for the basis, and should be tweaked to fit your needs │ │ │ │ better.

    │ │ │ │

    min_memory_usage returns settings that will use the minimal amount of │ │ │ │ @@ -5183,18 +5183,18 @@ │ │ │ │ pieces, instead of reading it all into memory before hashing.

    │ │ │ │

    This configuration is intended to be the starting point for embedded │ │ │ │ devices. It will significantly reduce memory usage.

    │ │ │ │

    high_performance_seed returns settings optimized for a seed box, │ │ │ │ serving many peers and that doesn't do any downloading. It has a 128 MB │ │ │ │ disk cache and has a limit of 400 files in its file pool. It support fast │ │ │ │ upload rates by allowing large send buffers.

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    setting_by_name() name_for_setting()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    name_for_setting() setting_by_name()

    │ │ │ │

    Declared in "libtorrent/settings_pack.hpp"

    │ │ │ │ 
    │ │ │ │  int setting_by_name (string_view name);
│ │ │ │  char const* name_for_setting (int s);
│ │ │ │
    │ │ │ │

    converts a setting integer (from the enums string_types, int_types or │ │ │ │ bool_types) to a string, and vice versa.

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,14 +1,14 @@ │ │ │ │ │ > │ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_] │ │ │ │ │ VVeerrssiioonn:: 2.0.11 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _s_e_t_t_i_n_g_s___p_a_c_k │ │ │ │ │ - o _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_)_ _s_e_t___s_t_r_(_) │ │ │ │ │ + o _s_e_t___s_t_r_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_) │ │ │ │ │ o _h_a_s___v_a_l_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _g_e_t___b_o_o_l_(_)_ _g_e_t___s_t_r_(_)_ _g_e_t___i_n_t_(_) │ │ │ │ │ o _e_n_u_m_ _t_y_p_e___b_a_s_e_s │ │ │ │ │ o _e_n_u_m_ _m_m_a_p___w_r_i_t_e___m_o_d_e___t │ │ │ │ │ o _e_n_u_m_ _s_u_g_g_e_s_t___m_o_d_e___t │ │ │ │ │ @@ -17,15 +17,15 @@ │ │ │ │ │ o _e_n_u_m_ _i_o___b_u_f_f_e_r___m_o_d_e___t │ │ │ │ │ o _e_n_u_m_ _b_a_n_d_w_i_d_t_h___m_i_x_e_d___a_l_g_o___t │ │ │ │ │ o _e_n_u_m_ _e_n_c___p_o_l_i_c_y │ │ │ │ │ o _e_n_u_m_ _e_n_c___l_e_v_e_l │ │ │ │ │ o _e_n_u_m_ _p_r_o_x_y___t_y_p_e___t │ │ │ │ │ * _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_) │ │ │ │ │ * _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)_ _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_) │ │ │ │ │ - * _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)_ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_) │ │ │ │ │ + * _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)_ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_) │ │ │ │ │ * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_) │ │ │ │ │ You have some control over _s_e_s_s_i_o_n configuration through the session:: │ │ │ │ │ apply_settings() member function. To change one or more configuration options, │ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k object and fill it with the settings to be set and pass │ │ │ │ │ it in to session::apply_settings(). │ │ │ │ │ The _s_e_t_t_i_n_g_s___p_a_c_k object is a collection of settings updates that are applied │ │ │ │ │ to the _s_e_s_s_i_o_n when passed to session::apply_settings(). It's empty when │ │ │ │ │ @@ -1435,18 +1435,18 @@ │ │ │ │ │ connect to the external NAT-PMP port (configured using announce_port) instead │ │ │ │ │ of the actual local listening port. │ │ │ │ │ struct settings_pack final : settings_interface │ │ │ │ │ { │ │ │ │ │ friend void aappppllyy__ppaacckk__iimmppll (settings_pack const* │ │ │ │ │ , aux::session_settings_single_thread& │ │ │ │ │ , std::vector*); │ │ │ │ │ - void sseett__iinntt (int name, int val) override; │ │ │ │ │ + void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ void sseett__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ + void sseett__iinntt (int name, int val) override; │ │ │ │ │ void sseett__bbooooll (int name, bool val) override; │ │ │ │ │ - void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ bool hhaass__vvaall (int name) const override; │ │ │ │ │ void cclleeaarr (); │ │ │ │ │ void cclleeaarr (int name); │ │ │ │ │ int ggeett__iinntt (int name) const override; │ │ │ │ │ bool ggeett__bbooooll (int name) const override; │ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override; │ │ │ │ │ void ffoorr__eeaacchh (Fun&& f) const; │ │ │ │ │ @@ -1522,19 +1522,19 @@ │ │ │ │ │ socks5, │ │ │ │ │ socks5_pw, │ │ │ │ │ http, │ │ │ │ │ http_pw, │ │ │ │ │ }; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__bbooooll(()) sseett__iinntt(()) sseett__ssttrr(()) ********** │ │ │ │ │ -void sseett__iinntt (int name, int val) override; │ │ │ │ │ +********** sseett__ssttrr(()) sseett__bbooooll(()) sseett__iinntt(()) ********** │ │ │ │ │ +void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ void sseett__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ +void sseett__iinntt (int name, int val) override; │ │ │ │ │ void sseett__bbooooll (int name, bool val) override; │ │ │ │ │ -void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ set a configuration option in the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of the enum values │ │ │ │ │ from string_types, int_types or bool_types. They must match the respective type │ │ │ │ │ of the set_* function. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** hhaass__vvaall(()) ********** │ │ │ │ │ bool hhaass__vvaall (int name) const override; │ │ │ │ │ queries whether the specified configuration option has a value set in this │ │ │ │ │ @@ -1710,16 +1710,16 @@ │ │ │ │ │ |_T_L_ _ _ _ _ _ _|_T_r_i_b_l_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ | │ │ │ │ │ There's an informal directory of client id's _h_e_r_e. │ │ │ │ │ The major, minor, revision and tag parameters are used to identify the version │ │ │ │ │ of your client. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ mmiinn__mmeemmoorryy__uussaaggee(()) hhiigghh__ppeerrffoorrmmaannccee__sseeeedd(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p" │ │ │ │ │ -settings_pack mmiinn__mmeemmoorryy__uussaaggee (); │ │ │ │ │ settings_pack hhiigghh__ppeerrffoorrmmaannccee__sseeeedd (); │ │ │ │ │ +settings_pack mmiinn__mmeemmoorryy__uussaaggee (); │ │ │ │ │ The default values of the _s_e_s_s_i_o_n settings are set for a regular bittorrent │ │ │ │ │ client running on a desktop system. There are functions that can set the │ │ │ │ │ _s_e_s_s_i_o_n settings to pre set settings for other environments. These can be used │ │ │ │ │ for the basis, and should be tweaked to fit your needs better. │ │ │ │ │ min_memory_usage returns settings that will use the minimal amount of RAM, at │ │ │ │ │ the potential expense of upload and download performance. It adjusts the socket │ │ │ │ │ buffer sizes, disables the disk cache, lowers the send buffer watermarks so │ │ │ │ │ @@ -1732,15 +1732,15 @@ │ │ │ │ │ This configuration is intended to be the starting point for embedded devices. │ │ │ │ │ It will significantly reduce memory usage. │ │ │ │ │ high_performance_seed returns settings optimized for a seed box, serving many │ │ │ │ │ peers and that doesn't do any downloading. It has a 128 MB disk cache and has a │ │ │ │ │ limit of 400 files in its file pool. It support fast upload rates by allowing │ │ │ │ │ large send buffers. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -************ sseettttiinngg__bbyy__nnaammee(()) nnaammee__ffoorr__sseettttiinngg(()) ************ │ │ │ │ │ +************ nnaammee__ffoorr__sseettttiinngg(()) sseettttiinngg__bbyy__nnaammee(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p" │ │ │ │ │ int sseettttiinngg__bbyy__nnaammee (string_view name); │ │ │ │ │ char const* nnaammee__ffoorr__sseettttiinngg (int s); │ │ │ │ │ converts a setting integer (from the enums string_types, int_types or │ │ │ │ │ bool_types) to a string, and vice versa. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ddeeffaauulltt__sseettttiinnggss(()) ************ │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Storage.html │ │ │ │ @@ -32,36 +32,36 @@ │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │
      │ │ │ │
    • file_slice
      • │ │ │ │
    • file_storage
        │ │ │ │
      • is_valid()
        • │ │ │ │
      • reserve()
        • │ │ │ │ -
      • add_file_borrow() add_file()
        • │ │ │ │ +
      • add_file() add_file_borrow()
        • │ │ │ │
      • rename_file()
        • │ │ │ │
      • map_block()
        • │ │ │ │
      • map_file()
        • │ │ │ │
      • num_files()
        • │ │ │ │
      • end_file()
        • │ │ │ │
      • file_range()
        • │ │ │ │
      • total_size()
        • │ │ │ │ -
      • num_pieces() set_num_pieces()
        • │ │ │ │ +
      • set_num_pieces() num_pieces()
        • │ │ │ │
      • end_piece()
        • │ │ │ │
      • last_piece()
        • │ │ │ │
      • piece_range()
        • │ │ │ │ -
      • set_piece_length() piece_length()
        • │ │ │ │ +
      • piece_length() set_piece_length()
        • │ │ │ │
      • piece_size()
        • │ │ │ │
      • piece_size2()
        • │ │ │ │
      • blocks_in_piece2()
        • │ │ │ │
      • blocks_per_piece()
        • │ │ │ │
      • set_name() name()
        • │ │ │ │
      • swap()
        • │ │ │ │
      • canonicalize()
        • │ │ │ │ -
      • symlink() root() file_path() file_size() hash() file_name() mtime() pad_file_at() root_ptr() file_offset()
        • │ │ │ │ -
      • file_piece_range() file_num_blocks() file_num_pieces()
        • │ │ │ │ +
      • symlink() root() file_path() file_size() file_offset() hash() root_ptr() pad_file_at() mtime() file_name()
        • │ │ │ │ +
      • file_num_pieces() file_num_blocks() file_piece_range()
        • │ │ │ │
      • file_first_piece_node() file_first_block_node()
        • │ │ │ │
      • file_path_hash()
        • │ │ │ │
      • all_path_hashes()
        • │ │ │ │
      • file_flags()
        • │ │ │ │
      • file_absolute_path()
        • │ │ │ │
      • file_index_at_offset() file_index_at_piece()
        • │ │ │ │
      • file_index_for_root()
        • │ │ │ │ @@ -117,76 +117,76 @@ │ │ │ │ size. Everything necessary to interpret a regular bittorrent storage │ │ │ │ file structure.

        │ │ │ │ 
        │ │ │ │  class file_storage
│ │ │ │  {
│ │ │ │     bool is_valid () const;
│ │ │ │     void reserve (int num_files);
│ │ │ │ -   void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ +   void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}
│ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │     void add_file_borrow (error_code& ec, string_view filename
│ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ +   void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ +      , file_flags_t file_flags = {}
│ │ │ │ +      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │     void add_file_borrow (string_view filename
│ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ -   void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ -      , file_flags_t file_flags = {}
│ │ │ │ -      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │     void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │     std::vector<file_slice> map_block (piece_index_t piece, std::int64_t offset
│ │ │ │        , std::int64_t size) const;
│ │ │ │     peer_request map_file (file_index_t file, std::int64_t offset, int size) const;
│ │ │ │     int num_files () const noexcept;
│ │ │ │     file_index_t end_file () const noexcept;
│ │ │ │     index_range<file_index_t> file_range () const noexcept;
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int num_pieces () const;
│ │ │ │     void set_num_pieces (int n);
│ │ │ │ +   int num_pieces () const;
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │     piece_index_t last_piece () const;
│ │ │ │     index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │     void set_piece_length (int l);
│ │ │ │     int piece_length () const;
│ │ │ │     int piece_size (piece_index_t index) const;
│ │ │ │     int piece_size2 (piece_index_t index) const;
│ │ │ │     int blocks_in_piece2 (piece_index_t index) const;
│ │ │ │     int blocks_per_piece () const;
│ │ │ │     std::string const& name () const;
│ │ │ │     void set_name (std::string const& n);
│ │ │ │     void swap (file_storage& ti) noexcept;
│ │ │ │     void canonicalize ();
│ │ │ │ -   char const* root_ptr (file_index_t const index) const;
│ │ │ │ -   std::string symlink (file_index_t index) const;
│ │ │ │     std::int64_t file_offset (file_index_t index) const;
│ │ │ │ +   string_view file_name (file_index_t index) const;
│ │ │ │ +   sha256_hash root (file_index_t index) const;
│ │ │ │ +   std::string symlink (file_index_t index) const;
│ │ │ │ +   char const* root_ptr (file_index_t const index) const;
│ │ │ │ +   std::int64_t file_size (file_index_t index) const;
│ │ │ │     bool pad_file_at (file_index_t index) const;
│ │ │ │     std::time_t mtime (file_index_t index) const;
│ │ │ │ -   string_view file_name (file_index_t index) const;
│ │ │ │     std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ -   std::int64_t file_size (file_index_t index) const;
│ │ │ │ -   sha256_hash root (file_index_t index) const;
│ │ │ │     sha1_hash hash (file_index_t index) const;
│ │ │ │ +   index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │     int file_num_blocks (file_index_t index) const;
│ │ │ │     int file_num_pieces (file_index_t index) const;
│ │ │ │ -   index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │     int file_first_piece_node (file_index_t index) const;
│ │ │ │     int file_first_block_node (file_index_t index) const;
│ │ │ │     std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │     void all_path_hashes (std::unordered_set<std::uint32_t>& table) const;
│ │ │ │     file_flags_t file_flags (file_index_t index) const;
│ │ │ │     bool file_absolute_path (file_index_t index) const;
│ │ │ │ -   file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │     file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │ +   file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │     file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │     piece_index_t piece_index_at_file (file_index_t f) const;
│ │ │ │     void sanitize_symlinks ();
│ │ │ │     bool v2 () const;
│ │ │ │  
│ │ │ │     static constexpr file_flags_t flag_pad_file  = 0_bit;
│ │ │ │     static constexpr file_flags_t flag_hidden  = 1_bit;
│ │ │ │ @@ -208,37 +208,37 @@
│ │ │ │  
        reserve()
        
│ │ │ │  
        │ │ │ │  void reserve (int num_files);
│ │ │ │  
        
│ │ │ │  
        allocates space for num_files in the internal file list. This can
│ │ │ │  be used to avoid reallocating the internal file list when the number
│ │ │ │  of files to be added is known up-front.
        
│ │ │ │ -
│ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    add_file_borrow() add_file()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    add_file() add_file_borrow()

    │ │ │ │ 
    │ │ │ │ -void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ +void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}
│ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │  void add_file_borrow (error_code& ec, string_view filename
│ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ +void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ +      , file_flags_t file_flags = {}
│ │ │ │ +      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │  void add_file_borrow (string_view filename
│ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ -void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ -      , file_flags_t file_flags = {}
│ │ │ │ -      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │
    │ │ │ │

    Adds a file to the file storage. The add_file_borrow version │ │ │ │ expects that filename is the file name (without a path) of │ │ │ │ the file that's being added. │ │ │ │ This memory is borrowed, i.e. it is the caller's │ │ │ │ responsibility to make sure it stays valid throughout the lifetime │ │ │ │ of this file_storage object or any copy of it. The same thing applies │ │ │ │ @@ -336,21 +336,21 @@ │ │ │ │ [report issue]

    │ │ │ │
    │ │ │ │

    total_size()

    │ │ │ │ 
    │ │ │ │  std::int64_t total_size () const;
│ │ │ │
    │ │ │ │

    returns the total number of bytes all the files in this torrent spans

    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    num_pieces() set_num_pieces()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    set_num_pieces() num_pieces()

    │ │ │ │ 
    │ │ │ │ -int num_pieces () const;
│ │ │ │  void set_num_pieces (int n);
│ │ │ │ +int num_pieces () const;
│ │ │ │
    │ │ │ │

    set and get the number of pieces in the torrent

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    end_piece()

    │ │ │ │ 
    │ │ │ │  piece_index_t end_piece () const;
│ │ │ │ @@ -370,18 +370,18 @@
│ │ │ │  
    piece_range()
    
│ │ │ │  
    │ │ │ │  index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns an implementation-defined type that can be used as the
│ │ │ │  container in a range-for loop. Where the values are the indices of all
│ │ │ │  pieces in the file_storage.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    set_piece_length() piece_length()

    │ │ │ │ + │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    piece_length() set_piece_length()

    │ │ │ │ 
    │ │ │ │  void set_piece_length (int l);
│ │ │ │  int piece_length () const;
│ │ │ │
    │ │ │ │

    set and get the size of each piece in this torrent. It must be a power of two │ │ │ │ and at least 16 kiB.

    │ │ │ │ [report issue]
    │ │ │ │ @@ -442,32 +442,32 @@ │ │ │ │ │ │ │ │

    arrange files and padding to match the canonical form required │ │ │ │ by BEP 52

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ - │ │ │ │ + │ │ │ │ -
    │ │ │ │ -

    file_piece_range() file_num_blocks() file_num_pieces()

    │ │ │ │ +[report issue]
    │ │ │ │ +
    │ │ │ │ +

    file_num_pieces() file_num_blocks() file_piece_range()

    │ │ │ │ 
    │ │ │ │ +index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │  int file_num_blocks (file_index_t index) const;
│ │ │ │  int file_num_pieces (file_index_t index) const;
│ │ │ │ -index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │
    │ │ │ │

    Returns the number of pieces or blocks the file at index spans, │ │ │ │ under the assumption that the file is aligned to the start of a piece. │ │ │ │ This is only meaningful for v2 torrents, where files are guaranteed │ │ │ │ such alignment. │ │ │ │ These numbers are used to size and navigate the merkle hash tree for │ │ │ │ each file.

    │ │ │ │ @@ -552,16 +552,16 @@ │ │ │ │ have an absolute path, i.e. is not anchored in the save path of the │ │ │ │ torrent.

    │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    file_index_at_offset() file_index_at_piece()

    │ │ │ │ 
    │ │ │ │ -file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │  file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │ +file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │
    │ │ │ │

    returns the index of the file at the given offset in the torrent

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    file_index_for_root()

    │ │ │ │ 
    │ │ │ │  file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,37 +3,37 @@
│ │ │ │ │  VVeerrssiioonn:: 2.0.11
│ │ │ │ │  _h_o_m_e
│ │ │ │ │  Table of contents
│ │ │ │ │      * _f_i_l_e___s_l_i_c_e
│ │ │ │ │      * _f_i_l_e___s_t_o_r_a_g_e
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _r_e_s_e_r_v_e_(_)
│ │ │ │ │ -          o _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)_ _a_d_d___f_i_l_e_(_)
│ │ │ │ │ +          o _a_d_d___f_i_l_e_(_)_ _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │            o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │            o _m_a_p___f_i_l_e_(_)
│ │ │ │ │            o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │            o _e_n_d___f_i_l_e_(_)
│ │ │ │ │            o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │            o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ -          o _n_u_m___p_i_e_c_e_s_(_)_ _s_e_t___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ +          o _s_e_t___n_u_m___p_i_e_c_e_s_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │            o _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │            o _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │            o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ -          o _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ +          o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │            o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │            o _p_i_e_c_e___s_i_z_e_2_(_)
│ │ │ │ │            o _b_l_o_c_k_s___i_n___p_i_e_c_e_2_(_)
│ │ │ │ │            o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │            o _s_e_t___n_a_m_e_(_)_ _n_a_m_e_(_)
│ │ │ │ │            o _s_w_a_p_(_)
│ │ │ │ │            o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ -          o _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)_ _f_i_l_e___p_a_t_h_(_)_ _f_i_l_e___s_i_z_e_(_)_ _h_a_s_h_(_)_ _f_i_l_e___n_a_m_e_(_)_ _m_t_i_m_e_(_)
│ │ │ │ │ -            _p_a_d___f_i_l_e___a_t_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)
│ │ │ │ │ -          o _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ +          o _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)_ _f_i_l_e___p_a_t_h_(_)_ _f_i_l_e___s_i_z_e_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _h_a_s_h_(_)
│ │ │ │ │ +            _r_o_o_t___p_t_r_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _m_t_i_m_e_(_)_ _f_i_l_e___n_a_m_e_(_)
│ │ │ │ │ +          o _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │            o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)
│ │ │ │ │            o _f_i_l_e___p_a_t_h___h_a_s_h_(_)
│ │ │ │ │            o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │            o _f_i_l_e___f_l_a_g_s_(_)
│ │ │ │ │            o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_)
│ │ │ │ │            o _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)_ _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)
│ │ │ │ │            o _f_i_l_e___i_n_d_e_x___f_o_r___r_o_o_t_(_)
│ │ │ │ │ @@ -77,80 +77,80 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_f_i_l_e___s_t_o_r_a_g_e_._h_p_p"
│ │ │ │ │  The file_storage class represents a file list and the piece size. Everything
│ │ │ │ │  necessary to interpret a regular bittorrent storage file structure.
│ │ │ │ │  class file_storage
│ │ │ │ │  {
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │     void rreesseerrvvee (int num_files);
│ │ │ │ │ -   void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ +   void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ +file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │     void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ +   void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ +      , file_flags_t file_flags = {}
│ │ │ │ │ +      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │ │     void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ -   void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ -file_size
│ │ │ │ │ -      , file_flags_t file_flags = {}
│ │ │ │ │ -      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │     std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │        , std::int64_t size) const;
│ │ │ │ │     peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │  const;
│ │ │ │ │     int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │     file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │     index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ -   int nnuumm__ppiieecceess () const;
│ │ │ │ │     void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ +   int nnuumm__ppiieecceess () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │     void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │     int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │     int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │     int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │     int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │     std::string const& nnaammee () const;
│ │ │ │ │     void sseett__nnaammee (std::string const& n);
│ │ │ │ │     void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │     void ccaannoonniiccaalliizzee ();
│ │ │ │ │ -   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -   std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │     std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +   string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +   std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +   std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │     bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │     std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -   string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │     std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │  "") const;
│ │ │ │ │ -   std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │     sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +   index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │     int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │     int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ -   index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │     std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │  save_path) const;
│ │ │ │ │     void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │     file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │     bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ -   file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │     file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ +   file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │     file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │     piece_index_t ppiieeccee__iinnddeexx__aatt__ffiillee (file_index_t f) const;
│ │ │ │ │     void ssaanniittiizzee__ssyymmlliinnkkss ();
│ │ │ │ │     bool vv22 () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr file_flags_t ffllaagg__ppaadd__ffiillee  = 0_bit;
│ │ │ │ │     static constexpr file_flags_t ffllaagg__hhiiddddeenn  = 1_bit;
│ │ │ │ │ @@ -166,33 +166,33 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreesseerrvvee(()) **********
│ │ │ │ │  void rreesseerrvvee (int num_files);
│ │ │ │ │  allocates space for num_files in the internal file list. This can be used to
│ │ │ │ │  avoid reallocating the internal file list when the number of files to be added
│ │ │ │ │  is known up-front.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ffiillee__bboorrrrooww(()) aadddd__ffiillee(()) **********
│ │ │ │ │ -void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ +********** aadddd__ffiillee(()) aadddd__ffiillee__bboorrrrooww(()) **********
│ │ │ │ │ +void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │  void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ +void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ +      , file_flags_t file_flags = {}
│ │ │ │ │ +      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │ │  void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │ -      , file_flags_t file_flags = {}
│ │ │ │ │ -      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │ │  Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │  filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │  memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │  stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │  it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │  byte binary SHA-1 hash of the file.
│ │ │ │ │  if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -261,17 +261,17 @@
│ │ │ │ │  range-for loop. Where the values are the indices of all files in the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │  std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │  returns the total number of bytes all the files in this torrent spans
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** nnuumm__ppiieecceess(()) sseett__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │ +********** sseett__nnuumm__ppiieecceess(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │  void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ +int nnuumm__ppiieecceess () const;
│ │ │ │ │  set and get the number of pieces in the torrent
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eenndd__ppiieeccee(()) **********
│ │ │ │ │  piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │  returns the index of the one-past-end piece in the file storage
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** llaasstt__ppiieeccee(()) **********
│ │ │ │ │ @@ -282,15 +282,15 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppiieeccee__rraannggee(()) **********
│ │ │ │ │  index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │  returns an implementation-defined type that can be used as the container in a
│ │ │ │ │  range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ +********** ppiieeccee__lleennggtthh(()) sseett__ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │  void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │  int ppiieeccee__lleennggtthh () const;
│ │ │ │ │  set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │ │  and at least 16 kiB.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │  int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ @@ -323,26 +323,26 @@
│ │ │ │ │  void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │  swap all content of tthhiiss with ttii.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │  void ccaannoonniiccaalliizzee ();
│ │ │ │ │  arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssyymmlliinnkk(()) rroooott(()) ffiillee__ppaatthh(()) ffiillee__ssiizzee(()) hhaasshh(()) ffiillee__nnaammee(()) mmttiimmee(())
│ │ │ │ │ -ppaadd__ffiillee__aatt(()) rroooott__ppttrr(()) ffiillee__ooffffsseett(()) **********
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +********** ssyymmlliinnkk(()) rroooott(()) ffiillee__ppaatthh(()) ffiillee__ssiizzee(()) ffiillee__ooffffsseett(()) hhaasshh(()) rroooott__ppttrr(())
│ │ │ │ │ +ppaadd__ffiillee__aatt(()) mmttiimmee(()) ffiillee__nnaammee(()) **********
│ │ │ │ │  std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │  bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │  std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │  std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │  const;
│ │ │ │ │ -std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │  sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │  These functions are used to query attributes of files at a given index.
│ │ │ │ │  The hash() is a SHA-1 hash of the file, or 0 if none was provided in the
│ │ │ │ │  torrent file. This can potentially be used to join a bittorrent network with
│ │ │ │ │  other file sharing networks.
│ │ │ │ │  root() returns the SHA-256 merkle tree root of the specified file, in case this
│ │ │ │ │  is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │ @@ -356,18 +356,18 @@
│ │ │ │ │  file_size() returns the size of a file.
│ │ │ │ │  pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │  file_name() returns jjuusstt the name of the file, whereas file_path() returns the
│ │ │ │ │  path (inside the torrent file) with the filename appended.
│ │ │ │ │  file_offset() returns the byte offset within the torrent file where this file
│ │ │ │ │  starts. It can be used to map the file to a piece index (given the piece size).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__bblloocckkss(()) ffiillee__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ +********** ffiillee__nnuumm__ppiieecceess(()) ffiillee__nnuumm__bblloocckkss(()) ffiillee__ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │  int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │  int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ -index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │  Returns the number of pieces or blocks the file atindexspans, under the
│ │ │ │ │  assumption that the file is aligned to the start of a piece. This is only
│ │ │ │ │  meaningful for v2 torrents, where files are guaranteed such alignment. These
│ │ │ │ │  numbers are used to size and navigate the merkle hash tree for each file.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) **********
│ │ │ │ │  int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ @@ -393,16 +393,16 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__aabbssoolluuttee__ppaatthh(()) **********
│ │ │ │ │  bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │  returns true if the file at the specified index has been renamed to have an
│ │ │ │ │  absolute path, i.e. is not anchored in the save path of the torrent.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__iinnddeexx__aatt__ooffffsseett(()) ffiillee__iinnddeexx__aatt__ppiieeccee(()) **********
│ │ │ │ │ -file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ +file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │  returns the index of the file at the given offset in the torrent
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__iinnddeexx__ffoorr__rroooott(()) **********
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │  finds the file with the given root hash and returns its index if there is no
│ │ │ │ │  file with the root hash, file_index_t{-1} is returned
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Handle.html
│ │ │ │ @@ -40,51 +40,51 @@
│ │ │ │  
  • partial_piece_info
    • 
│ │ │ │  
  • torrent_handle
│ │ │ │  
    • 
│ │ │ │  
  • hash_value()
    • 
│ │ │ │ @@ -94,16 +94,16 @@
│ │ │ │  
    block_info
    
│ │ │ │  
    Declared in "libtorrent/torrent_handle.hpp"
    
│ │ │ │  
    holds the state of a block in a piece. Who we requested
│ │ │ │  it from and how far along we are at downloading it.
    
│ │ │ │  
    │ │ │ │  struct block_info
│ │ │ │  {
│ │ │ │ -   tcp::endpoint peer () const;
│ │ │ │     void set_peer (tcp::endpoint const& ep);
│ │ │ │ +   tcp::endpoint peer () const;
│ │ │ │  
│ │ │ │     enum block_state_t
│ │ │ │     {
│ │ │ │        none,
│ │ │ │        requested,
│ │ │ │        writing,
│ │ │ │        finished,
│ │ │ │ @@ -115,16 +115,16 @@
│ │ │ │     unsigned num_peers:14;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    peer() set_peer()
    
│ │ │ │  
    │ │ │ │ -tcp::endpoint peer () const;
│ │ │ │  void set_peer (tcp::endpoint const& ep);
│ │ │ │ +tcp::endpoint peer () const;
│ │ │ │  
    
│ │ │ │  
    The peer is the ip address of the peer this block was downloaded from.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    enum block_state_t
    
│ │ │ │  
    Declared in "libtorrent/torrent_handle.hpp"
    
│ │ │ │  
│ │ │ │ @@ -263,110 +263,110 @@
│ │ │ │  handle will remain valid between two calls.
    
│ │ │ │  
│ │ │ │  
    │ │ │ │  struct torrent_handle
│ │ │ │  {
│ │ │ │     friend std::size_t hash_value (torrent_handle const& th);
│ │ │ │     torrent_handle () noexcept = default;
│ │ │ │ -   void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +   void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void read_piece (piece_index_t piece) const;
│ │ │ │     bool have_piece (piece_index_t piece) const;
│ │ │ │     void post_peer_info () const;
│ │ │ │     void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ -   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ -   void post_download_queue () const;
│ │ │ │     void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ -   void clear_piece_deadlines () const;
│ │ │ │ +   void post_download_queue () const;
│ │ │ │     void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │     void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ -   std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ -   void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ +   void clear_piece_deadlines () const;
│ │ │ │     void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +   void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ +   std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │     std::vector<open_file_state> file_status () const;
│ │ │ │     void clear_error () const;
│ │ │ │ -   void post_trackers () const;
│ │ │ │     void add_tracker (announce_entry const&) const;
│ │ │ │ +   void post_trackers () const;
│ │ │ │     void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │     std::vector<announce_entry> trackers () const;
│ │ │ │     void remove_url_seed (std::string const& url) const;
│ │ │ │ -   void add_url_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> url_seeds () const;
│ │ │ │ -   void add_http_seed (std::string const& url) const;
│ │ │ │ +   void add_url_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> http_seeds () const;
│ │ │ │     void remove_http_seed (std::string const& url) const;
│ │ │ │ +   void add_http_seed (std::string const& url) const;
│ │ │ │     void add_extension (
│ │ │ │        std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │        , client_data_t userdata = client_data_t{});
│ │ │ │     bool set_metadata (span<char const> metadata) const;
│ │ │ │     bool is_valid () const;
│ │ │ │ -   void resume () const;
│ │ │ │     void pause (pause_flags_t flags = {}) const;
│ │ │ │ -   void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +   void resume () const;
│ │ │ │     void set_flags (torrent_flags_t flags) const;
│ │ │ │ -   void unset_flags (torrent_flags_t flags) const;
│ │ │ │     torrent_flags_t flags () const;
│ │ │ │ +   void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +   void unset_flags (torrent_flags_t flags) const;
│ │ │ │     void flush_cache () const;
│ │ │ │     void force_recheck () const;
│ │ │ │     void save_resume_data (resume_data_flags_t flags = {}) const;
│ │ │ │     bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │     bool need_save_resume_data () const;
│ │ │ │ -   void queue_position_up () const;
│ │ │ │     void queue_position_top () const;
│ │ │ │ -   void queue_position_bottom () const;
│ │ │ │     void queue_position_down () const;
│ │ │ │     queue_position_t queue_position () const;
│ │ │ │ +   void queue_position_bottom () const;
│ │ │ │ +   void queue_position_up () const;
│ │ │ │     void queue_position_set (queue_position_t p) const;
│ │ │ │ +   void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ +      , std::string const& private_key
│ │ │ │ +      , std::string const& dh_params);
│ │ │ │     void set_ssl_certificate (std::string const& certificate
│ │ │ │        , std::string const& private_key
│ │ │ │        , std::string const& dh_params
│ │ │ │        , std::string const& passphrase = "");
│ │ │ │ -   void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ -      , std::string const& private_key
│ │ │ │ -      , std::string const& dh_params);
│ │ │ │ -   std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │     std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ +   std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │     std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ -   void post_piece_availability () const;
│ │ │ │     void piece_availability (std::vector<int>& avail) const;
│ │ │ │ +   void post_piece_availability () const;
│ │ │ │ +   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │     void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +   std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │     void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │     void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ -   std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ -   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ -   void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │     void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │     std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │     download_priority_t file_priority (file_index_t index) const;
│ │ │ │ +   void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ +   void force_lsd_announce () const;
│ │ │ │     void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │     void force_dht_announce () const;
│ │ │ │ -   void force_lsd_announce () const;
│ │ │ │     void scrape_tracker (int idx = -1) const;
│ │ │ │     int download_limit () const;
│ │ │ │ -   void set_upload_limit (int limit) const;
│ │ │ │ -   void set_download_limit (int limit) const;
│ │ │ │     int upload_limit () const;
│ │ │ │ +   void set_download_limit (int limit) const;
│ │ │ │ +   void set_upload_limit (int limit) const;
│ │ │ │     void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │     void clear_peers ();
│ │ │ │     void set_max_uploads (int max_uploads) const;
│ │ │ │     int max_uploads () const;
│ │ │ │     int max_connections () const;
│ │ │ │     void set_max_connections (int max_connections) const;
│ │ │ │     void move_storage (std::string const& save_path
│ │ │ │        , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │        ) const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │     info_hash_t info_hashes () const;
│ │ │ │     sha1_hash info_hash () const;
│ │ │ │     bool operator== (const torrent_handle& h) const;
│ │ │ │ -   bool operator!= (const torrent_handle& h) const;
│ │ │ │     bool operator< (const torrent_handle& h) const;
│ │ │ │ +   bool operator!= (const torrent_handle& h) const;
│ │ │ │     std::uint32_t id () const;
│ │ │ │     std::shared_ptr<torrent> native_handle () const;
│ │ │ │     client_data_t userdata () const;
│ │ │ │     bool in_session () const;
│ │ │ │  
│ │ │ │     static constexpr add_piece_flags_t overwrite_existing  = 0_bit;
│ │ │ │     static constexpr status_flags_t query_distributed_copies  = 0_bit;
│ │ │ │ @@ -398,16 +398,16 @@
│ │ │ │  
    
│ │ │ │  
    constructs a torrent handle that does not refer to a torrent.
│ │ │ │  i.e. is_valid() will return false.
    
│ │ │ │  [report issue]
│ │ │ │  
    
│ │ │ │  
    add_piece()
    
│ │ │ │  
    │ │ │ │ -void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │  void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │  
    
│ │ │ │  
    This function will write data to the storage as piece piece,
│ │ │ │  as if it had been downloaded from a peer.
    
│ │ │ │  
    By default, data that's already been downloaded is not overwritten by
│ │ │ │  this buffer. If you trust this data to be correct (and pass the piece
│ │ │ │  hash check) you may pass the overwrite_existing flag. This will
│ │ │ │  instruct libtorrent to overwrite any data that may already have been
│ │ │ │ @@ -462,21 +462,21 @@
│ │ │ │  a peer_info_alert. The alert contain a list of peer_info objects, one
│ │ │ │  for each connected peer.
    
│ │ │ │  
    get_peer_info() is synchronous and takes a reference to a vector
│ │ │ │  that will be cleared and filled with one entry for each peer
│ │ │ │  connected to this torrent, given the handle is valid. Each entry in
│ │ │ │  the vector contains information about that particular peer. See
│ │ │ │  peer_info.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    status() post_status()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    post_status() status()
    
│ │ │ │  
    │ │ │ │ -torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │  void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │  
    
│ │ │ │  
    status() will return a structure with information about the status
│ │ │ │  of this torrent. If the torrent_handle is invalid, it will throw
│ │ │ │  system_error exception. See torrent_status. The flags
│ │ │ │  argument filters what information is returned in the torrent_status.
│ │ │ │  Some information in there is relatively expensive to calculate, and if
│ │ │ │  you're not interested in it (and see performance issues), you can
│ │ │ │ @@ -492,32 +492,32 @@
│ │ │ │  what to include are defined in this class.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    get_download_queue() post_download_queue()
    
│ │ │ │  
    │ │ │ │  std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ -void post_download_queue () const;
│ │ │ │  void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ +void post_download_queue () const;
│ │ │ │  
    
│ │ │ │  
    post_download_queue() triggers a download_queue_alert to be
│ │ │ │  posted.
│ │ │ │  get_download_queue() is a synchronous call and returns a vector
│ │ │ │  with information about pieces that are partially downloaded or not
│ │ │ │  downloaded but partially requested. See partial_piece_info for the
│ │ │ │  fields in the returned vector.
    
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    clear_piece_deadlines() set_piece_deadline() reset_piece_deadline()
    
│ │ │ │  
    │ │ │ │ -void clear_piece_deadlines () const;
│ │ │ │  void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │  void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ +void clear_piece_deadlines () const;
│ │ │ │  
    
│ │ │ │  
    This function sets or resets the deadline associated with a specific
│ │ │ │  piece index (index). libtorrent will attempt to download this
│ │ │ │  entire piece before the deadline expires. This is not necessarily
│ │ │ │  possible, but pieces with a more recent deadline will always be
│ │ │ │  prioritized over pieces with a deadline further ahead in time. The
│ │ │ │  deadline (and flags) of a piece can be changed by calling this
│ │ │ │ @@ -528,22 +528,22 @@
│ │ │ │  
    deadline is the number of milliseconds until this piece should be
│ │ │ │  completed.
    
│ │ │ │  
    reset_piece_deadline removes the deadline from the piece. If it
│ │ │ │  hasn't already been downloaded, it will no longer be considered a
│ │ │ │  priority.
    
│ │ │ │  
    clear_piece_deadlines() removes deadlines on all pieces in
│ │ │ │  the torrent. As if reset_piece_deadline() was called on all pieces.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    post_file_progress() file_progress()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_progress() post_file_progress()
    
│ │ │ │  
    │ │ │ │ -std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ -void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │  void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ +std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │  
    
│ │ │ │  
    This function fills in the supplied vector, or returns a vector, with
│ │ │ │  the number of bytes downloaded of each file in this torrent. The
│ │ │ │  progress values are ordered the same as the files in the
│ │ │ │  torrent_info.
    
│ │ │ │  
    This operation is not very cheap. Its complexity is O(n + mj).
│ │ │ │  Where n is the number of files, m is the number of currently
│ │ │ │ @@ -572,23 +572,23 @@
│ │ │ │  
    
│ │ │ │  
    clear_error()
    
│ │ │ │  
    │ │ │ │  void clear_error () const;
│ │ │ │  
    
│ │ │ │  
    If the torrent is in an error state (i.e. torrent_status::error is
│ │ │ │  non-empty), this will clear the error and start the torrent again.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    trackers() add_tracker() replace_trackers() post_trackers()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_tracker() replace_trackers() trackers() post_trackers()
    
│ │ │ │  
    │ │ │ │ -void post_trackers () const;
│ │ │ │  void add_tracker (announce_entry const&) const;
│ │ │ │ +void post_trackers () const;
│ │ │ │  void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │  std::vector<announce_entry> trackers () const;
│ │ │ │  
    
│ │ │ │  
    trackers() returns the list of trackers for this torrent. The
│ │ │ │  announce entry contains both a string url which specify the
│ │ │ │  announce url for the tracker as well as an int tier, which is
│ │ │ │  specifies the order in which this tracker is tried. If you want
│ │ │ │ @@ -602,42 +602,42 @@
│ │ │ │  
    add_tracker() will look if the specified tracker is already in the
│ │ │ │  set. If it is, it doesn't do anything. If it's not in the current set
│ │ │ │  of trackers, it will insert it in the tier specified in the
│ │ │ │  announce_entry.
    
│ │ │ │  
    The updated set of trackers will be saved in the resume data, and when
│ │ │ │  a torrent is started with resume data, the trackers from the resume
│ │ │ │  data will replace the original ones.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    add_url_seed() url_seeds() remove_url_seed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    url_seeds() remove_url_seed() add_url_seed()
    
│ │ │ │  
    │ │ │ │  void remove_url_seed (std::string const& url) const;
│ │ │ │ -void add_url_seed (std::string const& url) const;
│ │ │ │  std::set<std::string> url_seeds () const;
│ │ │ │ +void add_url_seed (std::string const& url) const;
│ │ │ │  
    
│ │ │ │  
    add_url_seed() adds another url to the torrent's list of url
│ │ │ │  seeds. If the given url already exists in that list, the call has no
│ │ │ │  effect. The torrent will connect to the server and try to download
│ │ │ │  pieces from it, unless it's paused, queued, checking or seeding.
│ │ │ │  remove_url_seed() removes the given url if it exists already.
│ │ │ │  url_seeds() return a set of the url seeds currently in this
│ │ │ │  torrent. Note that URLs that fails may be removed automatically from
│ │ │ │  the list.
    
│ │ │ │  
    See http seeding for more information.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    http_seeds() add_http_seed() remove_http_seed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_http_seed() remove_http_seed() http_seeds()
    
│ │ │ │  
    │ │ │ │ -void add_http_seed (std::string const& url) const;
│ │ │ │  std::set<std::string> http_seeds () const;
│ │ │ │  void remove_http_seed (std::string const& url) const;
│ │ │ │ +void add_http_seed (std::string const& url) const;
│ │ │ │  
    
│ │ │ │  
    These functions are identical as the *_url_seed() variants, but
│ │ │ │  they operate on BEP 17 web seeds instead of BEP 19.
    
│ │ │ │  
    See http seeding for more information.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    add_extension()
    
│ │ │ │ @@ -684,16 +684,16 @@
│ │ │ │  network thread. Also unlike other functions, it never throws
│ │ │ │  the system_error exception.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    pause() resume()
    
│ │ │ │  
    │ │ │ │ -void resume () const;
│ │ │ │  void pause (pause_flags_t flags = {}) const;
│ │ │ │ +void resume () const;
│ │ │ │  
    
│ │ │ │  
    pause(), and resume() will disconnect all peers and reconnect
│ │ │ │  all peers respectively. When a torrent is paused, it will however
│ │ │ │  remember all share ratios to all peers and remember all potential (not
│ │ │ │  connected) peers. Torrents may be paused automatically if there is a
│ │ │ │  file error (e.g. disk full) or something similar. See
│ │ │ │  file_error_alert.
    
│ │ │ │ @@ -704,24 +704,24 @@
│ │ │ │  
    
│ │ │ │  
    Note
    
│ │ │ │  
    Torrents that are auto-managed may be automatically resumed again. It
│ │ │ │  does not make sense to pause an auto-managed torrent without making it
│ │ │ │  not auto-managed first. Torrents are auto-managed by default when added
│ │ │ │  to the session. For more information, see queuing.
    
│ │ │ │  
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    flags() set_flags() unset_flags()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    unset_flags() flags() set_flags()
    
│ │ │ │  
    │ │ │ │ -void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │  void set_flags (torrent_flags_t flags) const;
│ │ │ │ -void unset_flags (torrent_flags_t flags) const;
│ │ │ │  torrent_flags_t flags () const;
│ │ │ │ +void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +void unset_flags (torrent_flags_t flags) const;
│ │ │ │  
    
│ │ │ │  
    sets and gets the torrent state flags. See torrent_flags_t.
│ │ │ │  The set_flags overload that take a mask will affect all
│ │ │ │  flags part of the mask, and set their values to what the
│ │ │ │  flags argument is set to. This allows clearing and
│ │ │ │  setting flags in a single function call.
│ │ │ │  The set_flags overload that just takes flags, sets all
│ │ │ │ @@ -877,27 +877,27 @@
│ │ │ │  
    
│ │ │ │  
    Note
    
│ │ │ │  
    A torrent's resume data is considered saved as soon as the
│ │ │ │  save_resume_data_alert is posted. It is important to make sure this
│ │ │ │  alert is received and handled in order for this function to be
│ │ │ │  meaningful.
    
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    queue_position_bottom() queue_position_down() queue_position() queue_position_top() queue_position_up()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    queue_position() queue_position_top() queue_position_down() queue_position_bottom() queue_position_up()
    
│ │ │ │  
    │ │ │ │ -void queue_position_up () const;
│ │ │ │  void queue_position_top () const;
│ │ │ │ -void queue_position_bottom () const;
│ │ │ │  void queue_position_down () const;
│ │ │ │  queue_position_t queue_position () const;
│ │ │ │ +void queue_position_bottom () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │  
    
│ │ │ │  
    Every torrent that is added is assigned a queue position exactly one
│ │ │ │  greater than the greatest queue position of all existing torrents.
│ │ │ │  Torrents that are being seeded have -1 as their queue position, since
│ │ │ │  they're no longer in line to be downloaded.
    
│ │ │ │  
    When a torrent is removed or turns into a seed, all torrents with
│ │ │ │  greater queue positions have their positions decreased to fill in the
│ │ │ │ @@ -921,21 +921,21 @@
│ │ │ │  of all other torrents remain intact but their numerical queue position
│ │ │ │  shifts to make space for this torrent's new position
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    set_ssl_certificate_buffer() set_ssl_certificate()
    
│ │ │ │  
    │ │ │ │ +void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ +      , std::string const& private_key
│ │ │ │ +      , std::string const& dh_params);
│ │ │ │  void set_ssl_certificate (std::string const& certificate
│ │ │ │        , std::string const& private_key
│ │ │ │        , std::string const& dh_params
│ │ │ │        , std::string const& passphrase = "");
│ │ │ │ -void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ -      , std::string const& private_key
│ │ │ │ -      , std::string const& dh_params);
│ │ │ │  
    
│ │ │ │  
    For SSL torrents, use this to specify a path to a .pem file to use as
│ │ │ │  this client's certificate. The certificate must be signed by the
│ │ │ │  certificate in the .torrent file to be valid.
    
│ │ │ │  
    The set_ssl_certificate_buffer() overload takes the actual certificate,
│ │ │ │  private key and DH params as strings, rather than paths to files.
    
│ │ │ │  
    cert is a path to the (signed) certificate in .pem format
│ │ │ │ @@ -956,16 +956,16 @@
│ │ │ │  provide a valid cert. If you don't have a cert you won't be allowed to
│ │ │ │  connect to any peers.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    torrent_file() torrent_file_with_hashes()
    
│ │ │ │  
    │ │ │ │ -std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │  std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ +std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │  
    
│ │ │ │  
    torrent_file() returns a pointer to the torrent_info object
│ │ │ │  associated with this torrent. The torrent_info object may be a copy
│ │ │ │  of the internal object. If the torrent doesn't have metadata, the
│ │ │ │  pointer will not be initialized (i.e. a nullptr). The torrent may be
│ │ │ │  in a state without metadata only if it was started without a .torrent
│ │ │ │  file, e.g. by being added by magnet link.
    
│ │ │ │ @@ -1002,16 +1002,16 @@
│ │ │ │  vector. This is a blocking call that will synchronize with the
│ │ │ │  libtorrent network thread.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    piece_availability() post_piece_availability()
    
│ │ │ │  
    │ │ │ │ -void post_piece_availability () const;
│ │ │ │  void piece_availability (std::vector<int>& avail) const;
│ │ │ │ +void post_piece_availability () const;
│ │ │ │  
    
│ │ │ │  
    The piece availability is the number of peers that we are connected
│ │ │ │  that has advertised having a particular piece. This is the information
│ │ │ │  that libtorrent uses in order to prefer picking rare pieces.
    
│ │ │ │  
    post_piece_availability() will trigger a piece_availability_alert
│ │ │ │  to be posted.
    
│ │ │ │  
    piece_availability() fills the specified std::vector<int>
│ │ │ │ @@ -1020,19 +1020,19 @@
│ │ │ │  seeding the availability for all pieces is reported as 0.
    
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    prioritize_pieces() piece_priority() get_piece_priorities()
    
│ │ │ │  
    │ │ │ │ +download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │  void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │  void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │  void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ -std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ -download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │  
    
│ │ │ │  
    These functions are used to set and get the priority of individual
│ │ │ │  pieces. By default all pieces have priority 4. That means that the
│ │ │ │  random rarest first algorithm is effectively active for all pieces.
│ │ │ │  You may however change the priority of individual pieces. There are 8
│ │ │ │  priority levels. 0 means not to download the piece at all. Otherwise,
│ │ │ │  lower priority values means less likely to be picked. Piece priority
│ │ │ │ @@ -1054,24 +1054,24 @@
│ │ │ │  Invalid entries, where the piece index or priority is out of range, are
│ │ │ │  not allowed.
    
│ │ │ │  
    get_piece_priorities returns a vector with one element for each piece
│ │ │ │  in the torrent. Each element is the current priority of that piece.
    
│ │ │ │  
    It's possible to cancel the effect of file priorities by setting the
│ │ │ │  priorities for the affected pieces. Care has to be taken when mixing
│ │ │ │  usage of file- and piece priorities.
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    file_priority() get_file_priorities() prioritize_files()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    prioritize_files() file_priority() get_file_priorities()
    
│ │ │ │  
    │ │ │ │ -void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │  void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │  std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │  download_priority_t file_priority (file_index_t index) const;
│ │ │ │ +void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │  
    
│ │ │ │  
    index must be in the range [0, number_of_files).
    
│ │ │ │  
    file_priority() queries or sets the priority of file index.
    
│ │ │ │  
    prioritize_files() takes a vector that has at as many elements as
│ │ │ │  there are files in the torrent. Each entry is the priority of that
│ │ │ │  file. The function sets the priorities of all the pieces in the
│ │ │ │  torrent based on the vector.
    
│ │ │ │ @@ -1094,23 +1094,23 @@
│ │ │ │  file_prio_alert.
    
│ │ │ │  
    When combining file- and piece priorities, the resume file will record
│ │ │ │  both. When loading the resume data, the file priorities will be applied
│ │ │ │  first, then the piece priorities.
    
│ │ │ │  
    Moving data from a file into the part file is currently not
│ │ │ │  supported. If a file has its priority set to 0 after it has already
│ │ │ │  been created, it will not be moved into the partfile.
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    force_lsd_announce() force_reannounce() force_dht_announce()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    force_dht_announce() force_lsd_announce() force_reannounce()
    
│ │ │ │  
    │ │ │ │ +void force_lsd_announce () const;
│ │ │ │  void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │  void force_dht_announce () const;
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │  
    
│ │ │ │  
    force_reannounce() will force this torrent to do another tracker
│ │ │ │  request, to receive new peers. The seconds argument specifies how
│ │ │ │  many seconds from now to issue the tracker announces.
    
│ │ │ │  
    If the tracker's min_interval has not passed since the last
│ │ │ │  announce, the forced announce will be scheduled to happen immediately
│ │ │ │  as the min_interval expires. This is to honor trackers minimum
│ │ │ │ @@ -1134,25 +1134,25 @@
│ │ │ │  idx is >= 0, the tracker with the specified index will scraped.
    
│ │ │ │  
    A scrape request queries the tracker for statistics such as total
│ │ │ │  number of incomplete peers, complete peers, number of downloads etc.
    
│ │ │ │  
    This request will specifically update the num_complete and
│ │ │ │  num_incomplete fields in the torrent_status struct once it
│ │ │ │  completes. When it completes, it will generate a scrape_reply_alert.
│ │ │ │  If it fails, it will generate a scrape_failed_alert.
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    upload_limit() set_upload_limit() download_limit() set_download_limit()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    download_limit() set_download_limit() upload_limit() set_upload_limit()
    
│ │ │ │  
    │ │ │ │  int download_limit () const;
│ │ │ │ -void set_upload_limit (int limit) const;
│ │ │ │ -void set_download_limit (int limit) const;
│ │ │ │  int upload_limit () const;
│ │ │ │ +void set_download_limit (int limit) const;
│ │ │ │ +void set_upload_limit (int limit) const;
│ │ │ │  
    
│ │ │ │  
    set_upload_limit will limit the upload bandwidth used by this
│ │ │ │  particular torrent to the limit you set. It is given as the number of
│ │ │ │  bytes per second the torrent is allowed to upload.
│ │ │ │  set_download_limit works the same way but for download bandwidth
│ │ │ │  instead of upload bandwidth. Note that setting a higher limit on a
│ │ │ │  torrent then the global limit
│ │ │ │ @@ -1275,37 +1275,37 @@
│ │ │ │  
    rename_file()
    
│ │ │ │  
    │ │ │ │  void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │  
    
│ │ │ │  
    Renames the file with the given index asynchronously. The rename
│ │ │ │  operation is complete when either a file_renamed_alert or
│ │ │ │  file_rename_failed_alert is posted.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    info_hash() info_hashes()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    info_hashes() info_hash()
    
│ │ │ │  
    │ │ │ │  info_hash_t info_hashes () const;
│ │ │ │  sha1_hash info_hash () const;
│ │ │ │  
    
│ │ │ │  
    returns the info-hash(es) of the torrent. If this handle is to a
│ │ │ │  torrent that hasn't loaded yet (for instance by being added) by a
│ │ │ │  URL, the returned value is undefined.
│ │ │ │  The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │  truncated hash for v2 torrents. For the full v2 info-hash, use
│ │ │ │  info_hashes() instead.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │  
    
│ │ │ │ -
    operator<() operator==() operator!=()
    
│ │ │ │ +
    operator==() operator<() operator!=()
    
│ │ │ │  
    │ │ │ │  bool operator== (const torrent_handle& h) const;
│ │ │ │ -bool operator!= (const torrent_handle& h) const;
│ │ │ │  bool operator< (const torrent_handle& h) const;
│ │ │ │ +bool operator!= (const torrent_handle& h) const;
│ │ │ │  
    
│ │ │ │  
    comparison operators. The order of the torrents is unspecified
│ │ │ │  but stable.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    id()
    
│ │ │ │  
    │ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -9,67 +9,67 @@
│ │ │ │ │      * _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o
│ │ │ │ │      * _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │            o _t_o_r_r_e_n_t___h_a_n_d_l_e_(_)
│ │ │ │ │            o _a_d_d___p_i_e_c_e_(_)
│ │ │ │ │            o _r_e_a_d___p_i_e_c_e_(_)
│ │ │ │ │            o _h_a_v_e___p_i_e_c_e_(_)
│ │ │ │ │            o _g_e_t___p_e_e_r___i_n_f_o_(_)_ _p_o_s_t___p_e_e_r___i_n_f_o_(_)
│ │ │ │ │ -          o _s_t_a_t_u_s_(_)_ _p_o_s_t___s_t_a_t_u_s_(_)
│ │ │ │ │ +          o _p_o_s_t___s_t_a_t_u_s_(_)_ _s_t_a_t_u_s_(_)
│ │ │ │ │            o _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │            o _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ │ -          o _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ +          o _f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │            o _f_i_l_e___s_t_a_t_u_s_(_)
│ │ │ │ │            o _c_l_e_a_r___e_r_r_o_r_(_)
│ │ │ │ │ -          o _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ -          o _a_d_d___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)
│ │ │ │ │ -          o _h_t_t_p___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ +          o _a_d_d___t_r_a_c_k_e_r_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ +          o _u_r_l___s_e_e_d_s_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ +          o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)
│ │ │ │ │            o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │            o _s_e_t___m_e_t_a_d_a_t_a_(_)
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)
│ │ │ │ │ -          o _f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)
│ │ │ │ │ +          o _u_n_s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)
│ │ │ │ │            o _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │            o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │            o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │            o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ -          o _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)
│ │ │ │ │ -            _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │ +          o _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │ +            _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │            o _q_u_e_u_e___p_o_s_i_t_i_o_n___s_e_t_(_)
│ │ │ │ │            o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)
│ │ │ │ │            o _t_o_r_r_e_n_t___f_i_l_e_(_)_ _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │            o _p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │            o _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │            o _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ -          o _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)
│ │ │ │ │ -          o _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ +          o _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ +          o _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)
│ │ │ │ │            o _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ -          o _u_p_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ -            _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +          o _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +            _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │            o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │            o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │            o _m_a_x___u_p_l_o_a_d_s_(_)_ _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │            o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │            o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ -          o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ -          o _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)
│ │ │ │ │ +          o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ +          o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)
│ │ │ │ │            o _i_d_(_)
│ │ │ │ │            o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │            o _u_s_e_r_d_a_t_a_(_)
│ │ │ │ │            o _i_n___s_e_s_s_i_o_n_(_)
│ │ │ │ │      * _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ bblloocckk__iinnffoo ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │  holds the state of a block in a piece. Who we requested it from and how far
│ │ │ │ │  along we are at downloading it.
│ │ │ │ │  struct block_info
│ │ │ │ │  {
│ │ │ │ │ -   _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │     void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ +   _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  
│ │ │ │ │     enum block_state_t
│ │ │ │ │     {
│ │ │ │ │        none,
│ │ │ │ │        requested,
│ │ │ │ │        writing,
│ │ │ │ │        finished,
│ │ │ │ │ @@ -78,16 +78,16 @@
│ │ │ │ │     unsigned bytes_progress:15;
│ │ │ │ │     unsigned block_size:15;
│ │ │ │ │     unsigned state:2;
│ │ │ │ │     unsigned num_peers:14;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppeeeerr(()) sseett__ppeeeerr(()) **********
│ │ │ │ │ -_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ +_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  The peer is the ip address of the peer this block was downloaded from.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennuumm bblloocckk__ssttaattee__tt **********
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │   _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
│ │ │ │ │  |_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │  |none     |0    |This block has not been downloaded or requested form any   |
│ │ │ │ │ @@ -175,120 +175,120 @@
│ │ │ │ │  the handle is no longer referring to a torrent. There is one exception _i_s___v_a_l_i_d
│ │ │ │ │  _(_) will never throw. Since the torrents are processed by a background thread,
│ │ │ │ │  there is no guarantee that a handle will remain valid between two calls.
│ │ │ │ │  struct torrent_handle
│ │ │ │ │  {
│ │ │ │ │     friend std::size_t hhaasshh__vvaalluuee (torrent_handle const& th);
│ │ │ │ │     ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │ -   void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ -add_piece_flags_t flags = {}) const;
│ │ │ │ │     void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +   void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ +add_piece_flags_t flags = {}) const;
│ │ │ │ │     void rreeaadd__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │     bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │     void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │     void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ -   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │     void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │     std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -   void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │     void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ -   void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ +   void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │     void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │     void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ -   std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ -const;
│ │ │ │ │ +   void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ +   void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │     void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │  file_progress_flags_t flags = {}) const;
│ │ │ │ │ -   void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ +   std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ +const;
│ │ │ │ │     std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │     void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ -   void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │     void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +   void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │     void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │     std::vector ttrraacckkeerrss () const;
│ │ │ │ │     void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -   void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │     std::set uurrll__sseeeeddss () const;
│ │ │ │ │ -   void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +   void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │     std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │     void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +   void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │     void aadddd__eexxtteennssiioonn (
│ │ │ │ │        std::function(torrent_handle const&,
│ │ │ │ │  client_data_t)> const& ext
│ │ │ │ │        , client_data_t userdata = client_data_t{});
│ │ │ │ │     bool sseett__mmeettaaddaattaa (span metadata) const;
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │ -   void rreessuummee () const;
│ │ │ │ │     void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ -   void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ +   void rreessuummee () const;
│ │ │ │ │     void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ -   void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │     torrent_flags_t ffllaaggss () const;
│ │ │ │ │ +   void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ +   void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │     void fflluusshh__ccaacchhee () const;
│ │ │ │ │     void ffoorrccee__rreecchheecckk () const;
│ │ │ │ │     void ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags = {}) const;
│ │ │ │ │     bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │     bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │     queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │ +   void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ +      , std::string const& private_key
│ │ │ │ │ +      , std::string const& dh_params);
│ │ │ │ │     void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │        , std::string const& private_key
│ │ │ │ │        , std::string const& dh_params
│ │ │ │ │        , std::string const& passphrase = "");
│ │ │ │ │ -   void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ -      , std::string const& private_key
│ │ │ │ │ -      , std::string const& dh_params);
│ │ │ │ │ -   std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │     std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ +   std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │     std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ -   void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │     void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ +   void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ +   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │     void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │     void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │  const;
│ │ │ │ │     void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │  const;
│ │ │ │ │ -   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ -   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ -   void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │     void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │     std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │     download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ +   void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +   void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │     void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t =
│ │ │ │ │  {}) const;
│ │ │ │ │     void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ -   void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │     void ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ │     int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ -   void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -   void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ +   void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ +   void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     void ccoonnnneecctt__ppeeeerr (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ │     void cclleeaarr__ppeeeerrss ();
│ │ │ │ │     void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │     int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │     int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │     void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │     void mmoovvee__ssttoorraaggee (std::string const& save_path
│ │ │ │ │        , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ │        ) const;
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │     info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │     sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │     bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ -   bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │     bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ +   bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │     std::uint32_t iidd () const;
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │     client_data_t uusseerrddaattaa () const;
│ │ │ │ │     bool iinn__sseessssiioonn () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr add_piece_flags_t oovveerrwwrriittee__eexxiissttiinngg  = 0_bit;
│ │ │ │ │     static constexpr status_flags_t qquueerryy__ddiissttrriibbuutteedd__ccooppiieess  = 0_bit;
│ │ │ │ │ @@ -315,18 +315,18 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoorrrreenntt__hhaannddllee(()) **********
│ │ │ │ │  ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │  constructs a torrent handle that does not refer to a torrent. i.e. _i_s___v_a_l_i_d_(_)
│ │ │ │ │  will return false.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__ppiieeccee(()) **********
│ │ │ │ │ -void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │  void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t flags
│ │ │ │ │  = {}) const;
│ │ │ │ │ +void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t
│ │ │ │ │ +flags = {}) const;
│ │ │ │ │  This function will write data to the storage as piece piece, as if it had been
│ │ │ │ │  downloaded from a peer.
│ │ │ │ │  By default, data that's already been downloaded is not overwritten by this
│ │ │ │ │  buffer. If you trust this data to be correct (and pass the piece hash check)
│ │ │ │ │  you may pass the overwrite_existing flag. This will instruct libtorrent to
│ │ │ │ │  overwrite any data that may already have been downloaded with this data.
│ │ │ │ │  Since the data is written asynchronously, you may know that is passed or failed
│ │ │ │ │ @@ -367,17 +367,17 @@
│ │ │ │ │  _p_e_e_r___i_n_f_o___a_l_e_r_t. The _a_l_e_r_t contain a list of _p_e_e_r___i_n_f_o objects, one for each
│ │ │ │ │  connected peer.
│ │ │ │ │  get_peer_info() is synchronous and takes a reference to a vector that will be
│ │ │ │ │  cleared and filled with one _e_n_t_r_y for each peer connected to this torrent,
│ │ │ │ │  given the handle is valid. Each _e_n_t_r_y in the vector contains information about
│ │ │ │ │  that particular peer. See _p_e_e_r___i_n_f_o.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssttaattuuss(()) ppoosstt__ssttaattuuss(()) **********
│ │ │ │ │ -torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +********** ppoosstt__ssttaattuuss(()) ssttaattuuss(()) **********
│ │ │ │ │  void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │  status() will return a structure with information about the status of this
│ │ │ │ │  torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e is invalid, it will throw system_error
│ │ │ │ │  exception. See _t_o_r_r_e_n_t___s_t_a_t_u_s. The flags argument filters what information is
│ │ │ │ │  returned in the _t_o_r_r_e_n_t___s_t_a_t_u_s. Some information in there is relatively
│ │ │ │ │  expensive to calculate, and if you're not interested in it (and see performance
│ │ │ │ │  issues), you can filter them out.
│ │ │ │ │  The status() function will block until the internal libtorrent thread responds
│ │ │ │ │ @@ -387,27 +387,27 @@
│ │ │ │ │  In order to get regular updates for torrents whose status changes, consider
│ │ │ │ │  calling session::post_torrent_updates()`` instead.
│ │ │ │ │  By default everything is included. The flags you can use to decide what to
│ │ │ │ │  iinncclluuddee are defined in this class.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ggeett__ddoowwnnllooaadd__qquueeuuee(()) ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │  std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │  void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ +void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │  post_download_queue() triggers a download_queue_alert to be posted.
│ │ │ │ │  get_download_queue() is a synchronous call and returns a vector with
│ │ │ │ │  information about pieces that are partially downloaded or not downloaded but
│ │ │ │ │  partially requested. See _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o for the fields in the returned
│ │ │ │ │  vector.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │ -void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │  void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │  void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ +void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │  This function sets or resets the deadline associated with a specific piece
│ │ │ │ │  index (index). libtorrent will attempt to download this entire piece before the
│ │ │ │ │  deadline expires. This is not necessarily possible, but pieces with a more
│ │ │ │ │  recent deadline will always be prioritized over pieces with a deadline further
│ │ │ │ │  ahead in time. The deadline (and flags) of a piece can be changed by calling
│ │ │ │ │  this function again.
│ │ │ │ │  If the piece is already downloaded when this call is made, nothing happens,
│ │ │ │ │ @@ -415,20 +415,20 @@
│ │ │ │ │  same effect as calling _r_e_a_d___p_i_e_c_e_(_) for index.
│ │ │ │ │  deadline is the number of milliseconds until this piece should be completed.
│ │ │ │ │  reset_piece_deadline removes the deadline from the piece. If it hasn't already
│ │ │ │ │  been downloaded, it will no longer be considered a priority.
│ │ │ │ │  clear_piece_deadlines() removes deadlines on all pieces in the torrent. As if
│ │ │ │ │  _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_) was called on all pieces.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ -std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ -const;
│ │ │ │ │ +********** ffiillee__pprrooggrreessss(()) ppoosstt__ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ +void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │  void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ -void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ +std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ +const;
│ │ │ │ │  This function fills in the supplied vector, or returns a vector, with the
│ │ │ │ │  number of bytes downloaded of each file in this torrent. The progress values
│ │ │ │ │  are ordered the same as the files in the _t_o_r_r_e_n_t___i_n_f_o.
│ │ │ │ │  This operation is not very cheap. Its complexity is OO((nn ++ mmjj)). Where nn is the
│ │ │ │ │  number of files, mm is the number of currently downloading pieces and jj is the
│ │ │ │ │  number of blocks in a piece.
│ │ │ │ │  The flags parameter can be used to specify the granularity of the file
│ │ │ │ │ @@ -449,17 +449,17 @@
│ │ │ │ │  See _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__eerrrroorr(()) **********
│ │ │ │ │  void cclleeaarr__eerrrroorr () const;
│ │ │ │ │  If the torrent is in an error state (i.e. torrent_status::error is non-empty),
│ │ │ │ │  this will clear the error and start the torrent again.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) rreeppllaaccee__ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │ -void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ +********** aadddd__ttrraacckkeerr(()) rreeppllaaccee__ttrraacckkeerrss(()) ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │  void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │  void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │  std::vector ttrraacckkeerrss () const;
│ │ │ │ │  trackers() returns the list of trackers for this torrent. The announce _e_n_t_r_y
│ │ │ │ │  contains both a string url which specify the announce url for the tracker as
│ │ │ │ │  well as an _i_n_t tier, which is specifies the order in which this tracker is
│ │ │ │ │  tried. If you want libtorrent to use another list of trackers for this torrent,
│ │ │ │ │  you can use replace_trackers() which takes a list of the same form as the one
│ │ │ │ │ @@ -470,30 +470,30 @@
│ │ │ │ │  add_tracker() will look if the specified tracker is already in the set. If it
│ │ │ │ │  is, it doesn't do anything. If it's not in the current set of trackers, it will
│ │ │ │ │  insert it in the tier specified in the _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │  The updated set of trackers will be saved in the resume data, and when a
│ │ │ │ │  torrent is started with resume data, the trackers from the resume data will
│ │ │ │ │  replace the original ones.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) rreemmoovvee__uurrll__sseeeedd(()) **********
│ │ │ │ │ +********** uurrll__sseeeeddss(()) rreemmoovvee__uurrll__sseeeedd(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │  void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │  std::set uurrll__sseeeeddss () const;
│ │ │ │ │ +void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │  add_url_seed() adds another url to the torrent's list of url seeds. If the
│ │ │ │ │  given url already exists in that list, the call has no effect. The torrent will
│ │ │ │ │  connect to the server and try to download pieces from it, unless it's paused,
│ │ │ │ │  queued, checking or seeding. remove_url_seed() removes the given url if it
│ │ │ │ │  exists already. url_seeds() return a set of the url seeds currently in this
│ │ │ │ │  torrent. Note that URLs that fails may be removed automatically from the list.
│ │ │ │ │  See _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhttttpp__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +********** aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) **********
│ │ │ │ │  std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │  void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │  These functions are identical as the *_url_seed() variants, but they operate on
│ │ │ │ │  _B_E_P_ _1_7 web seeds instead of _B_E_P_ _1_9.
│ │ │ │ │  See _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__eexxtteennssiioonn(()) **********
│ │ │ │ │  void aadddd__eexxtteennssiioonn (
│ │ │ │ │        std::function(torrent_handle const&,
│ │ │ │ │ @@ -525,35 +525,35 @@
│ │ │ │ │  Clients should only use _i_s___v_a_l_i_d_(_) to determine if the result of session::
│ │ │ │ │  find_torrent() was successful.
│ │ │ │ │  Unlike other member functions which return a value, _i_s___v_a_l_i_d_(_) completes
│ │ │ │ │  immediately, without blocking on a result from the network thread. Also unlike
│ │ │ │ │  other functions, it never throws the system_error exception.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppaauussee(()) rreessuummee(()) **********
│ │ │ │ │ -void rreessuummee () const;
│ │ │ │ │  void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ +void rreessuummee () const;
│ │ │ │ │  pause(), and resume() will disconnect all peers and reconnect all peers
│ │ │ │ │  respectively. When a torrent is paused, it will however remember all share
│ │ │ │ │  ratios to all peers and remember all potential (not connected) peers. Torrents
│ │ │ │ │  may be paused automatically if there is a file error (e.g. disk full) or
│ │ │ │ │  something similar. See _f_i_l_e___e_r_r_o_r___a_l_e_r_t.
│ │ │ │ │  For possible values of the flags parameter, see pause_flags_t.
│ │ │ │ │  To know if a torrent is paused or not, call torrent_handle::flags() and check
│ │ │ │ │  for the torrent_status::paused flag.
│ │ │ │ │  Note
│ │ │ │ │  Torrents that are auto-managed may be automatically resumed again. It does not
│ │ │ │ │  make sense to pause an auto-managed torrent without making it not auto-managed
│ │ │ │ │  first. Torrents are auto-managed by default when added to the _s_e_s_s_i_o_n. For more
│ │ │ │ │  information, see _q_u_e_u_i_n_g.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffllaaggss(()) sseett__ffllaaggss(()) uunnsseett__ffllaaggss(()) **********
│ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ +********** uunnsseett__ffllaaggss(()) ffllaaggss(()) sseett__ffllaaggss(()) **********
│ │ │ │ │  void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ -void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │  torrent_flags_t ffllaaggss () const;
│ │ │ │ │ +void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ +void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │  sets and gets the torrent state flags. See _t_o_r_r_e_n_t___f_l_a_g_s___t. The set_flags
│ │ │ │ │  overload that take a mask will affect all flags part of the mask, and set their
│ │ │ │ │  values to what the flags argument is set to. This allows clearing and setting
│ │ │ │ │  flags in a single function call. The set_flags overload that just takes flags,
│ │ │ │ │  sets all the specified flags and leave any other flags unchanged. unset_flags
│ │ │ │ │  clears the specified flags, while leaving any other flags unchanged.
│ │ │ │ │  Theseed_modeflag is special, it can only be cleared once the torrent has been
│ │ │ │ │ @@ -677,21 +677,21 @@
│ │ │ │ │  thread. A way to avoid blocking is to instead call _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) directly,
│ │ │ │ │  specifying the conditions under which resume data should be saved.
│ │ │ │ │  Note
│ │ │ │ │  A torrent's resume data is considered saved as soon as the
│ │ │ │ │  _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t is posted. It is important to make sure this _a_l_e_r_t is
│ │ │ │ │  received and handled in order for this function to be meaningful.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__uupp(()) **********
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__uupp(()) **********
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │  queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │  Every torrent that is added is assigned a queue position exactly one greater
│ │ │ │ │  than the greatest queue position of all existing torrents. Torrents that are
│ │ │ │ │  being seeded have -1 as their queue position, since they're no longer in line
│ │ │ │ │  to be downloaded.
│ │ │ │ │  When a torrent is removed or turns into a seed, all torrents with greater queue
│ │ │ │ │  positions have their positions decreased to fill in the space in the sequence.
│ │ │ │ │  queue_position() returns the torrent's position in the download queue. The
│ │ │ │ │ @@ -706,21 +706,21 @@
│ │ │ │ │  ********** qquueeuuee__ppoossiittiioonn__sseett(()) **********
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │  updates the position in the queue for this torrent. The relative order of all
│ │ │ │ │  other torrents remain intact but their numerical queue position shifts to make
│ │ │ │ │  space for this torrent's new position
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr(()) sseett__ssssll__cceerrttiiffiiccaattee(()) **********
│ │ │ │ │ +void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ +      , std::string const& private_key
│ │ │ │ │ +      , std::string const& dh_params);
│ │ │ │ │  void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │        , std::string const& private_key
│ │ │ │ │        , std::string const& dh_params
│ │ │ │ │        , std::string const& passphrase = "");
│ │ │ │ │ -void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ -      , std::string const& private_key
│ │ │ │ │ -      , std::string const& dh_params);
│ │ │ │ │  For SSL torrents, use this to specify a path to a .pem file to use as this
│ │ │ │ │  client's certificate. The certificate must be signed by the certificate in the
│ │ │ │ │  .torrent file to be valid.
│ │ │ │ │  The _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_) overload takes the actual certificate, private
│ │ │ │ │  key and DH params as strings, rather than paths to files.
│ │ │ │ │  cert is a path to the (signed) certificate in .pem format corresponding to this
│ │ │ │ │  torrent.
│ │ │ │ │ @@ -735,16 +735,16 @@
│ │ │ │ │  suspend connecting to any peers until it has one. It's typically desirable to
│ │ │ │ │  resume the torrent after setting the SSL certificate.
│ │ │ │ │  If you receive a _t_o_r_r_e_n_t___n_e_e_d___c_e_r_t___a_l_e_r_t, you need to call this to provide a
│ │ │ │ │  valid cert. If you don't have a cert you won't be allowed to connect to any
│ │ │ │ │  peers.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoorrrreenntt__ffiillee(()) ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) **********
│ │ │ │ │ -std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │  std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ +std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │  _t_o_r_r_e_n_t___f_i_l_e_(_) returns a pointer to the _t_o_r_r_e_n_t___i_n_f_o object associated with
│ │ │ │ │  this torrent. The _t_o_r_r_e_n_t___i_n_f_o object may be a copy of the internal object. If
│ │ │ │ │  the torrent doesn't have metadata, the pointer will not be initialized (i.e. a
│ │ │ │ │  nullptr). The torrent may be in a state without metadata only if it was started
│ │ │ │ │  without a .torrent file, e.g. by being added by magnet link.
│ │ │ │ │  Note that the _t_o_r_r_e_n_t___i_n_f_o object returned here may be a different instance
│ │ │ │ │  than the one added to the _s_e_s_s_i_o_n, with different attributes like piece layers,
│ │ │ │ │ @@ -771,32 +771,32 @@
│ │ │ │ │  ********** ppiieeccee__llaayyeerrss(()) **********
│ │ │ │ │  std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │  returns the piece layers for all files in the torrent. If this is a v1 torrent
│ │ │ │ │  (and doesn't have any piece layers) it returns an empty vector. This is a
│ │ │ │ │  blocking call that will synchronize with the libtorrent network thread.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppiieeccee__aavvaaiillaabbiilliittyy(()) ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │ -void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │  void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ +void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │  The piece availability is the number of peers that we are connected that has
│ │ │ │ │  advertised having a particular piece. This is the information that libtorrent
│ │ │ │ │  uses in order to prefer picking rare pieces.
│ │ │ │ │  post_piece_availability() will trigger a _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y___a_l_e_r_t to be posted.
│ │ │ │ │  piece_availability() fills the specified std::vector with the availability
│ │ │ │ │  for each piece in this torrent. libtorrent does not keep track of availability
│ │ │ │ │  for seeds, so if the torrent is seeding the availability for all pieces is
│ │ │ │ │  reported as 0.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** pprriioorriittiizzee__ppiieecceess(()) ppiieeccee__pprriioorriittyy(()) ggeett__ppiieeccee__pprriioorriittiieess(()) **********
│ │ │ │ │ +download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │  void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │  void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │  void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │ -std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ -download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │  These functions are used to set and get the priority of individual pieces. By
│ │ │ │ │  default all pieces have priority 4. That means that the random rarest first
│ │ │ │ │  algorithm is effectively active for all pieces. You may however change the
│ │ │ │ │  priority of individual pieces. There are 8 priority levels. 0 means not to
│ │ │ │ │  download the piece at all. Otherwise, lower priority values means less likely
│ │ │ │ │  to be picked. Piece priority takes precedence over piece availability. Every
│ │ │ │ │  piece with priority 7 will be attempted to be picked before a priority 6 piece
│ │ │ │ │ @@ -816,19 +816,19 @@
│ │ │ │ │  where the piece index or priority is out of range, are not allowed.
│ │ │ │ │  get_piece_priorities returns a vector with one element for each piece in the
│ │ │ │ │  torrent. Each element is the current priority of that piece.
│ │ │ │ │  It's possible to cancel the effect of ffiillee priorities by setting the priorities
│ │ │ │ │  for the affected pieces. Care has to be taken when mixing usage of file- and
│ │ │ │ │  piece priorities.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) pprriioorriittiizzee__ffiilleess(()) **********
│ │ │ │ │ -void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +********** pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │  void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │  std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │  download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ +void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │  index must be in the range [0, number_of_files).
│ │ │ │ │  file_priority() queries or sets the priority of file index.
│ │ │ │ │  prioritize_files() takes a vector that has at as many elements as there are
│ │ │ │ │  files in the torrent. Each _e_n_t_r_y is the priority of that file. The function
│ │ │ │ │  sets the priorities of all the pieces in the torrent based on the vector.
│ │ │ │ │  get_file_priorities() returns a vector with the priorities of all files.
│ │ │ │ │  The priority values are the same as for _p_i_e_c_e___p_r_i_o_r_i_t_y_(_). See
│ │ │ │ │ @@ -847,19 +847,19 @@
│ │ │ │ │  When combining file- and piece priorities, the resume file will record both.
│ │ │ │ │  When loading the resume data, the file priorities will be applied first, then
│ │ │ │ │  the piece priorities.
│ │ │ │ │  Moving data from a file into the part file is currently not supported. If a
│ │ │ │ │  file has its priority set to 0 aafftteerr it has already been created, it will not
│ │ │ │ │  be moved into the partfile.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffoorrccee__llssdd__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__ddhhtt__aannnnoouunnccee(()) **********
│ │ │ │ │ +********** ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) **********
│ │ │ │ │ +void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │  void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = {})
│ │ │ │ │  const;
│ │ │ │ │  void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ -void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │  force_reannounce() will force this torrent to do another tracker request, to
│ │ │ │ │  receive new peers. The seconds argument specifies how many seconds from now to
│ │ │ │ │  issue the tracker announces.
│ │ │ │ │  If the tracker's min_interval has not passed since the last announce, the
│ │ │ │ │  forced announce will be scheduled to happen immediately as the min_interval
│ │ │ │ │  expires. This is to honor trackers minimum re-announce interval settings.
│ │ │ │ │  The tracker_index argument specifies which tracker to re-announce. If set to -
│ │ │ │ │ @@ -877,20 +877,20 @@
│ │ │ │ │  A scrape request queries the tracker for statistics such as total number of
│ │ │ │ │  incomplete peers, complete peers, number of downloads etc.
│ │ │ │ │  This request will specifically update the num_complete and num_incomplete
│ │ │ │ │  fields in the _t_o_r_r_e_n_t___s_t_a_t_u_s struct once it completes. When it completes, it
│ │ │ │ │  will generate a _s_c_r_a_p_e___r_e_p_l_y___a_l_e_r_t. If it fails, it will generate a
│ │ │ │ │  _s_c_r_a_p_e___f_a_i_l_e_d___a_l_e_r_t.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │ +********** ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(())
│ │ │ │ │  **********
│ │ │ │ │  int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ -void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ +void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ +void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  set_upload_limit will limit the upload bandwidth used by this particular
│ │ │ │ │  torrent to the limit you set. It is given as the number of bytes per second the
│ │ │ │ │  torrent is allowed to upload. set_download_limit works the same way but for
│ │ │ │ │  download bandwidth instead of upload bandwidth. Note that setting a higher
│ │ │ │ │  limit on a torrent then the global limit (settings_pack::upload_rate_limit)
│ │ │ │ │  will not override the global rate limit. The torrent can never upload more than
│ │ │ │ │  the global rate limit.
│ │ │ │ │ @@ -982,27 +982,27 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreennaammee__ffiillee(()) **********
│ │ │ │ │  void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │  Renames the file with the given index asynchronously. The rename operation is
│ │ │ │ │  complete when either a _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t or _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t is
│ │ │ │ │  posted.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ +********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │  info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │  sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │  returns the info-hash(es) of the torrent. If this handle is to a torrent that
│ │ │ │ │  hasn't loaded yet (for instance by being added) by a URL, the returned value is
│ │ │ │ │  undefined. The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │ │  truncated hash for v2 torrents. For the full v2 info-hash, use info_hashes()
│ │ │ │ │  instead.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr<<(()) ooppeerraattoorr====(()) ooppeerraattoorr!!==(()) **********
│ │ │ │ │ +********** ooppeerraattoorr====(()) ooppeerraattoorr<<(()) ooppeerraattoorr!!==(()) **********
│ │ │ │ │  bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ -bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │  bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ +bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │  comparison operators. The order of the torrents is unspecified but stable.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iidd(()) **********
│ │ │ │ │  std::uint32_t iidd () const;
│ │ │ │ │  returns a unique identifier for this torrent. It's not a dense index. It's not
│ │ │ │ │  preserved across sessions.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Info.html
│ │ │ │ @@ -41,23 +41,23 @@
│ │ │ │  
  • load_torrent_limits
    • 
│ │ │ │  
  • torrent_info
      
│ │ │ │  
    • torrent_info()
      • 
│ │ │ │  
    • ~torrent_info()
      • 
│ │ │ │  
    • orig_files() files()
      • 
│ │ │ │  
    • rename_file()
      • 
│ │ │ │  
    • remap_files()
      • 
│ │ │ │ -
    • trackers() clear_trackers() add_tracker()
      • 
│ │ │ │ -
    • similar_torrents() collections()
      • 
│ │ │ │ -
    • set_web_seeds() add_http_seed() add_url_seed() web_seeds()
      • 
│ │ │ │ +
    • add_tracker() trackers() clear_trackers()
      • 
│ │ │ │ +
    • collections() similar_torrents()
      • 
│ │ │ │ +
    • add_http_seed() set_web_seeds() add_url_seed() web_seeds()
      • 
│ │ │ │  
    • total_size()
      • 
│ │ │ │  
    • num_pieces() piece_length()
      • 
│ │ │ │  
    • blocks_per_piece()
      • 
│ │ │ │  
    • end_piece() last_piece() piece_range()
      • 
│ │ │ │ -
    • info_hash() info_hashes()
      • 
│ │ │ │ -
    • v2() v1()
      • 
│ │ │ │ +
    • info_hashes() info_hash()
      • 
│ │ │ │ +
    • v1() v2()
      • 
│ │ │ │  
    • num_files()
      • 
│ │ │ │  
    • map_block()
      • 
│ │ │ │  
    • map_file()
      • 
│ │ │ │  
    • ssl_cert()
      • 
│ │ │ │  
    • is_valid()
      • 
│ │ │ │  
    • priv()
      • 
│ │ │ │  
    • is_i2p()
      • 
│ │ │ │ @@ -197,69 +197,69 @@
│ │ │ │  
      
│ │ │ │  
      torrent_info
      
│ │ │ │  
      Declared in "libtorrent/torrent_info.hpp"
      
│ │ │ │  
      the torrent_info class holds the information found in a .torrent file.
      
│ │ │ │  
      │ │ │ │  class torrent_info
│ │ │ │  {
│ │ │ │ -   torrent_info (torrent_info const& t);
│ │ │ │ -   torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +   explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │     torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -   explicit torrent_info (std::string const& filename);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │     torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │     torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ +   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │     torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -   explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │     torrent_info (char const* buffer, int size);
│ │ │ │ -   torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   torrent_info (torrent_info const& t);
│ │ │ │ +   explicit torrent_info (std::string const& filename);
│ │ │ │     ~torrent_info ();
│ │ │ │     file_storage const& orig_files () const;
│ │ │ │     file_storage const& files () const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │     void remap_files (file_storage const& f);
│ │ │ │ -   void clear_trackers ();
│ │ │ │ -   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │     void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │     std::vector<announce_entry> const& trackers () const;
│ │ │ │ +   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ +   void clear_trackers ();
│ │ │ │     std::vector<sha1_hash> similar_torrents () const;
│ │ │ │     std::vector<std::string> collections () const;
│ │ │ │     void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ -   std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ -   void add_http_seed (std::string const& url
│ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │     void add_url_seed (std::string const& url
│ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ +   void add_http_seed (std::string const& url
│ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ +   std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int num_pieces () const;
│ │ │ │     int piece_length () const;
│ │ │ │ +   int num_pieces () const;
│ │ │ │     int blocks_per_piece () const;
│ │ │ │ +   index_range<piece_index_t> piece_range () const;
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │     piece_index_t last_piece () const;
│ │ │ │ -   index_range<piece_index_t> piece_range () const;
│ │ │ │     info_hash_t const& info_hashes () const;
│ │ │ │     sha1_hash info_hash () const noexcept;
│ │ │ │     bool v2 () const;
│ │ │ │     bool v1 () const;
│ │ │ │     int num_files () const;
│ │ │ │     std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ │        , std::int64_t offset, int size) const;
│ │ │ │     peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ │     string_view ssl_cert () const;
│ │ │ │     bool is_valid () const;
│ │ │ │     bool priv () const;
│ │ │ │     bool is_i2p () const;
│ │ │ │     int piece_size (piece_index_t index) const;
│ │ │ │ -   char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │     sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │ +   char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │     bool is_loaded () const;
│ │ │ │     const std::string& name () const;
│ │ │ │     std::time_t creation_date () const;
│ │ │ │     const std::string& creator () const;
│ │ │ │     const std::string& comment () const;
│ │ │ │     std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │ │     void add_node (std::pair<std::string, int> const& node);
│ │ │ │ @@ -269,27 +269,27 @@
│ │ │ │     span<char const> piece_layer (file_index_t) const;
│ │ │ │     void free_piece_layers ();
│ │ │ │  };
│ │ │ │  
      
│ │ │ │  [report issue]
      
│ │ │ │  
      torrent_info()
      
│ │ │ │  
      │ │ │ │ -torrent_info (torrent_info const& t);
│ │ │ │ -torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │  torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │  torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │  torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ +torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │  torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │  torrent_info (char const* buffer, int size);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (torrent_info const& t);
│ │ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ │  
      
│ │ │ │  
      The constructor that takes an info-hash will initialize the info-hash
│ │ │ │  to the given value, but leave all other fields empty. This is used
│ │ │ │  internally when downloading torrents without the metadata. The
│ │ │ │  metadata will be created by libtorrent as soon as it has been
│ │ │ │  downloaded from the swarm.
      
│ │ │ │  
      The constructor that takes a bdecode_node will create a torrent_info
│ │ │ │ @@ -376,64 +376,64 @@
│ │ │ │  
      
│ │ │ │  
      Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │  instance, download all data in a torrent to a single file, or to a
│ │ │ │  number of fixed size sector aligned files, regardless of the number
│ │ │ │  and sizes of the files in the torrent.
      
│ │ │ │  
      The new specified file_storage must have the exact same size as
│ │ │ │  the current one.
      
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      trackers() clear_trackers() add_tracker()
      
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      add_tracker() trackers() clear_trackers()
      
│ │ │ │  
      │ │ │ │ -void clear_trackers ();
│ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │  void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │  std::vector<announce_entry> const& trackers () const;
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ +void clear_trackers ();
│ │ │ │  
      
│ │ │ │  
      add_tracker() adds a tracker to the announce-list. The tier
│ │ │ │  determines the order in which the trackers are to be tried.
│ │ │ │  The trackers() function will return a sorted vector of
│ │ │ │  announce_entry. Each announce entry contains a string, which is
│ │ │ │  the tracker url, and a tier index. The tier index is the high-level
│ │ │ │  priority. No matter which trackers that works or not, the ones with
│ │ │ │  lower tier will always be tried before the one with higher tier
│ │ │ │  number. For more information, see announce_entry.
      
│ │ │ │  
      trackers() returns all entries from announce-list.
      
│ │ │ │  
      clear_trackers() removes all trackers from announce-list.
      
│ │ │ │ -
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      similar_torrents() collections()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      collections() similar_torrents()
      
│ │ │ │  
      │ │ │ │  std::vector<sha1_hash> similar_torrents () const;
│ │ │ │  std::vector<std::string> collections () const;
│ │ │ │  
      
│ │ │ │  
      These two functions are related to BEP 38 (mutable torrents). The
│ │ │ │  vectors returned from these correspond to the "similar" and
│ │ │ │  "collections" keys in the .torrent file. Both info-hashes and
│ │ │ │  collections from within the info-dict and from outside of it are
│ │ │ │  included.
      
│ │ │ │ -
│ │ │ │  
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      set_web_seeds() add_http_seed() add_url_seed() web_seeds()
      
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      add_http_seed() set_web_seeds() add_url_seed() web_seeds()
      
│ │ │ │  
      │ │ │ │  void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ -void add_http_seed (std::string const& url
│ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │  void add_url_seed (std::string const& url
│ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ +void add_http_seed (std::string const& url
│ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ +std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │  
      
│ │ │ │  
      web_seeds() returns all url seeds and http seeds in the torrent.
│ │ │ │  Each entry is a web_seed_entry and may refer to either a url seed
│ │ │ │  or http seed.
      
│ │ │ │  
      add_url_seed() and add_http_seed() adds one url to the list of
│ │ │ │  url/http seeds.
      
│ │ │ │  
      set_web_seeds() replaces all web seeds with the ones specified in
│ │ │ │ @@ -458,16 +458,16 @@
│ │ │ │  the total size will be larger than the sum of all (regular) file
│ │ │ │  sizes.
      
│ │ │ │  
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      num_pieces() piece_length()
      
│ │ │ │  
      │ │ │ │ -int num_pieces () const;
│ │ │ │  int piece_length () const;
│ │ │ │ +int num_pieces () const;
│ │ │ │  
      
│ │ │ │  
      piece_length() and num_pieces() returns the number of byte
│ │ │ │  for each piece and the total number of pieces, respectively. The
│ │ │ │  difference between piece_size() and piece_length() is that
│ │ │ │  piece_size() takes the piece index as argument and gives you the
│ │ │ │  exact size of that piece. It will always be the same as
│ │ │ │  piece_length() except in the case of the last piece, which may be
│ │ │ │ @@ -482,39 +482,39 @@
│ │ │ │  may be fewer in the last piece)
      
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      end_piece() last_piece() piece_range()
      
│ │ │ │  
      │ │ │ │ +index_range<piece_index_t> piece_range () const;
│ │ │ │  piece_index_t end_piece () const;
│ │ │ │  piece_index_t last_piece () const;
│ │ │ │ -index_range<piece_index_t> piece_range () const;
│ │ │ │  
      
│ │ │ │  
      last_piece() returns the index to the last piece in the torrent and
│ │ │ │  end_piece() returns the index to the one-past-end piece in the
│ │ │ │  torrent
│ │ │ │  piece_range() returns an implementation-defined type that can be
│ │ │ │  used as the container in a range-for loop. Where the values are the
│ │ │ │  indices of all pieces in the file_storage.
      
│ │ │ │ -
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      info_hash() info_hashes()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      info_hashes() info_hash()
      
│ │ │ │  
      │ │ │ │  info_hash_t const& info_hashes () const;
│ │ │ │  sha1_hash info_hash () const noexcept;
│ │ │ │  
      
│ │ │ │  
      returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │  info_hashes() to get an object that may hold both a v1 and v2
│ │ │ │  info-hash
      
│ │ │ │ -
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      v2() v1()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      v1() v2()
      
│ │ │ │  
      │ │ │ │  bool v2 () const;
│ │ │ │  bool v1 () const;
│ │ │ │  
      
│ │ │ │  
      returns whether this torrent has v1 and/or v2 metadata, respectively.
│ │ │ │  Hybrid torrents have both. These are shortcuts for
│ │ │ │  info_hashes().has_v1() and info_hashes().has_v2() calls.
      
│ │ │ │ @@ -595,16 +595,16 @@
│ │ │ │  
      returns the piece size of file with index. This will be the same as piece_length(),
│ │ │ │  except for the last piece, which may be shorter.
      
│ │ │ │  
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      hash_for_piece_ptr() hash_for_piece()
      
│ │ │ │  
      │ │ │ │ -char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │  sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │ +char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │  
      
│ │ │ │  
      hash_for_piece() takes a piece-index and returns the 20-bytes
│ │ │ │  sha1-hash for that piece and info_hash() returns the 20-bytes
│ │ │ │  sha1-hash for the info-section of the torrent file.
│ │ │ │  hash_for_piece_ptr() returns a pointer to the 20 byte sha1 digest
│ │ │ │  for the piece. Note that the string is not 0-terminated.
      
│ │ │ │  [report issue]
      
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -10,23 +10,23 @@
│ │ │ │ │      * _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │      * _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │            o _t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │            o _~_t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │            o _o_r_i_g___f_i_l_e_s_(_)_ _f_i_l_e_s_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │            o _r_e_m_a_p___f_i_l_e_s_(_)
│ │ │ │ │ -          o _t_r_a_c_k_e_r_s_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ -          o _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_)
│ │ │ │ │ -          o _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)
│ │ │ │ │ +          o _a_d_d___t_r_a_c_k_e_r_(_)_ _t_r_a_c_k_e_r_s_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ +          o _c_o_l_l_e_c_t_i_o_n_s_(_)_ _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ +          o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)
│ │ │ │ │            o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │            o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │            o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │            o _e_n_d___p_i_e_c_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ -          o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ -          o _v_2_(_)_ _v_1_(_)
│ │ │ │ │ +          o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ +          o _v_1_(_)_ _v_2_(_)
│ │ │ │ │            o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │            o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │            o _m_a_p___f_i_l_e_(_)
│ │ │ │ │            o _s_s_l___c_e_r_t_(_)
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _p_r_i_v_(_)
│ │ │ │ │            o _i_s___i_2_p_(_)
│ │ │ │ │ @@ -120,74 +120,74 @@
│ │ │ │ │        the max number of bdecode tokens
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ttoorrrreenntt__iinnffoo ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p"
│ │ │ │ │  the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file.
│ │ │ │ │  class torrent_info
│ │ │ │ │  {
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │     ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │     file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │     file_storage const& ffiilleess () const;
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │     void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ │ -   void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ -   void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │     void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ │     std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +   void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ +   void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │     std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │     std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │     void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ -   std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ -   void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │     void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │  headers_t());
│ │ │ │ │ +   void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ +   std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ -   int nnuumm__ppiieecceess () const;
│ │ │ │ │     int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +   int nnuumm__ppiieecceess () const;
│ │ │ │ │     int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ +   index_range ppiieeccee__rraannggee () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ -   index_range ppiieeccee__rraannggee () const;
│ │ │ │ │     info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │     sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │     bool vv22 () const;
│ │ │ │ │     bool vv11 () const;
│ │ │ │ │     int nnuumm__ffiilleess () const;
│ │ │ │ │     std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ │        , std::int64_t offset, int size) const;
│ │ │ │ │     peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int
│ │ │ │ │  size) const;
│ │ │ │ │     string_view ssssll__cceerrtt () const;
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │     bool pprriivv () const;
│ │ │ │ │     bool iiss__ii22pp () const;
│ │ │ │ │     int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ -   char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │     sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ +   char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │     bool iiss__llooaaddeedd () const;
│ │ │ │ │     const std::string& nnaammee () const;
│ │ │ │ │     std::time_t ccrreeaattiioonn__ddaattee () const;
│ │ │ │ │     const std::string& ccrreeaattoorr () const;
│ │ │ │ │     const std::string& ccoommmmeenntt () const;
│ │ │ │ │     std::vector> const& nnooddeess () const;
│ │ │ │ │     void aadddd__nnooddee (std::pair const& node);
│ │ │ │ │ @@ -196,29 +196,29 @@
│ │ │ │ │     bdecode_node iinnffoo (char const* key) const;
│ │ │ │ │     span iinnffoo__sseeccttiioonn () const;
│ │ │ │ │     span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ │     void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │  The constructor that takes an info-hash will initialize the info-hash to the
│ │ │ │ │  given value, but leave all other fields empty. This is used internally when
│ │ │ │ │  downloading torrents without the metadata. The metadata will be created by
│ │ │ │ │  libtorrent as soon as it has been downloaded from the swarm.
│ │ │ │ │  The constructor that takes a _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │  from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │  represents a tree node in an bencoded file. To load an ordinary .torrent file
│ │ │ │ │ @@ -284,49 +284,49 @@
│ │ │ │ │  Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │ │  instance, download all data in a torrent to a single file, or to a number of
│ │ │ │ │  fixed size sector aligned files, regardless of the number and sizes of the
│ │ │ │ │  files in the torrent.
│ │ │ │ │  The new specified file_storage must have the exact same size as the current
│ │ │ │ │  one.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttrraacckkeerrss(()) cclleeaarr__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ +********** aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │  void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ │  std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │  add_tracker() adds a tracker to the announce-list. The tier determines the
│ │ │ │ │  order in which the trackers are to be tried. The trackers() function will
│ │ │ │ │  return a sorted vector of _a_n_n_o_u_n_c_e___e_n_t_r_y. Each announce _e_n_t_r_y contains a
│ │ │ │ │  string, which is the tracker url, and a tier index. The tier index is the high-
│ │ │ │ │  level priority. No matter which trackers that works or not, the ones with lower
│ │ │ │ │  tier will always be tried before the one with higher tier number. For more
│ │ │ │ │  information, see _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │  trackers() returns all entries from announce-list.
│ │ │ │ │  clear_trackers() removes all trackers from announce-list.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ │ +********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │  std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │  std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │  These two functions are related to _B_E_P_ _3_8 (mutable torrents). The vectors
│ │ │ │ │  returned from these correspond to the "similar" and "collections" keys in the
│ │ │ │ │  .torrent file. Both info-hashes and collections from within the info-dict and
│ │ │ │ │  from outside of it are included.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │ +********** aadddd__hhttttpp__sseeeedd(()) sseett__wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │  void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ -std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │  void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │  headers_t());
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ +std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │  web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is
│ │ │ │ │  a web_seed_entry and may refer to either a url seed or http seed.
│ │ │ │ │  add_url_seed() and add_http_seed() adds one url to the list of url/http seeds.
│ │ │ │ │  set_web_seeds() replaces all web seeds with the ones specified in the seeds
│ │ │ │ │  vector.
│ │ │ │ │  The extern_auth argument can be used for other authorization schemes than basic
│ │ │ │ │  HTTP authorization. If set, it will override any username and password found in
│ │ │ │ │ @@ -340,44 +340,44 @@
│ │ │ │ │  std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │  total_size() returns the total number of bytes the torrent-file represents.
│ │ │ │ │  Note that this is the number of pieces times the piece size (modulo the last
│ │ │ │ │  piece possibly being smaller). With pad files, the total size will be larger
│ │ │ │ │  than the sum of all (regular) file sizes.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │  int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +int nnuumm__ppiieecceess () const;
│ │ │ │ │  piece_length() and num_pieces() returns the number of byte for each piece and
│ │ │ │ │  the total number of pieces, respectively. The difference between piece_size()
│ │ │ │ │  and piece_length() is that piece_size() takes the piece index as argument and
│ │ │ │ │  gives you the exact size of that piece. It will always be the same as
│ │ │ │ │  piece_length() except in the case of the last piece, which may be smaller.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │  int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │  returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │  in the last piece)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eenndd__ppiieeccee(()) llaasstt__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +index_range ppiieeccee__rraannggee () const;
│ │ │ │ │  piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │  piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ -index_range ppiieeccee__rraannggee () const;
│ │ │ │ │  last_piece() returns the index to the last piece in the torrent and end_piece()
│ │ │ │ │  returns the index to the one-past-end piece in the torrent piece_range()
│ │ │ │ │  returns an implementation-defined type that can be used as the container in a
│ │ │ │ │  range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ +********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │  info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │  sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │  returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │ │  info_hashes() to get an object that may hold both a v1 and v2 info-hash
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** vv22(()) vv11(()) **********
│ │ │ │ │ +********** vv11(()) vv22(()) **********
│ │ │ │ │  bool vv22 () const;
│ │ │ │ │  bool vv11 () const;
│ │ │ │ │  returns whether this torrent has v1 and/or v2 metadata, respectively. Hybrid
│ │ │ │ │  torrents have both. These are shortcuts for info_hashes().has_v1() and
│ │ │ │ │  info_hashes().has_v2() calls.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnuumm__ffiilleess(()) **********
│ │ │ │ │ @@ -428,16 +428,16 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │  int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │  returns the piece size of file with index. This will be the same as
│ │ │ │ │  _p_i_e_c_e___l_e_n_g_t_h_(_), except for the last piece, which may be shorter.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** hhaasshh__ffoorr__ppiieeccee__ppttrr(()) hhaasshh__ffoorr__ppiieeccee(()) **********
│ │ │ │ │ -char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │  sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ +char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │  hash_for_piece() takes a piece-index and returns the 20-bytes sha1-hash for
│ │ │ │ │  that piece and info_hash() returns the 20-bytes sha1-hash for the info-section
│ │ │ │ │  of the torrent file. hash_for_piece_ptr() returns a pointer to the 20 byte sha1
│ │ │ │ │  digest for the piece. Note that the string is not 0-terminated.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnaammee(()) **********
│ │ │ │ │  const std::string& nnaammee () const;
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Trackers.html
│ │ │ │ @@ -31,15 +31,15 @@
│ │ │ │  
      home
      
│ │ │ │  
      
│ │ │ │  
      Table of contents
      
│ │ │ │  
│ │ │ │  
      
│ │ │ │  [report issue]
      
│ │ │ │  
      announce_infohash
      
│ │ │ │ @@ -131,18 +131,18 @@
│ │ │ │  
      announce_entry
      
│ │ │ │  
      Declared in "libtorrent/announce_entry.hpp"
      
│ │ │ │  
      this class holds information about one bittorrent tracker, as it
│ │ │ │  relates to a specific torrent.
      
│ │ │ │  
      │ │ │ │  struct announce_entry
│ │ │ │  {
│ │ │ │ -   announce_entry& operator= (announce_entry const&) &;
│ │ │ │ -   ~announce_entry ();
│ │ │ │     announce_entry ();
│ │ │ │ +   announce_entry& operator= (announce_entry const&) &;
│ │ │ │     explicit announce_entry (string_view u);
│ │ │ │ +   ~announce_entry ();
│ │ │ │     announce_entry (announce_entry const&);
│ │ │ │  
│ │ │ │     enum tracker_source
│ │ │ │     {
│ │ │ │        source_torrent,
│ │ │ │        source_client,
│ │ │ │        source_magnet_link,
│ │ │ │ @@ -154,23 +154,23 @@
│ │ │ │     std::vector<announce_endpoint> endpoints;
│ │ │ │     std::uint8_t tier  = 0;
│ │ │ │     std::uint8_t fail_limit  = 0;
│ │ │ │     std::uint8_t source:4;
│ │ │ │     bool verified:1;
│ │ │ │  };
│ │ │ │  
      
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
      
│ │ │ │ -
      ~announce_entry() announce_entry() operator=()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      announce_entry() operator=() ~announce_entry()
      
│ │ │ │  
      │ │ │ │ -announce_entry& operator= (announce_entry const&) &;
│ │ │ │ -~announce_entry ();
│ │ │ │  announce_entry ();
│ │ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ │  explicit announce_entry (string_view u);
│ │ │ │ +~announce_entry ();
│ │ │ │  announce_entry (announce_entry const&);
│ │ │ │  
      
│ │ │ │  
      constructs a tracker announce entry with u as the URL.
      
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      enum tracker_source
      
│ │ │ │  
      Declared in "libtorrent/announce_entry.hpp"
      
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2,15 +2,15 @@
│ │ │ │ │  _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │  VVeerrssiioonn:: 2.0.11
│ │ │ │ │  _h_o_m_e
│ │ │ │ │  Table of contents
│ │ │ │ │      * _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │      * _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │      * _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │ -          o _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ +          o _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)
│ │ │ │ │            o _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ aannnnoouunnccee__iinnffoohhaasshh ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │  struct announce_infohash
│ │ │ │ │  {
│ │ │ │ │     std::string message;
│ │ │ │ │ @@ -78,18 +78,18 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ aannnnoouunnccee__eennttrryy ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │  this class holds information about one bittorrent tracker, as it relates to a
│ │ │ │ │  specific torrent.
│ │ │ │ │  struct announce_entry
│ │ │ │ │  {
│ │ │ │ │ -   announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ -   ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │     aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +   announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │     explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +   ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │     aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │  
│ │ │ │ │     enum tracker_source
│ │ │ │ │     {
│ │ │ │ │        source_torrent,
│ │ │ │ │        source_client,
│ │ │ │ │        source_magnet_link,
│ │ │ │ │ @@ -101,19 +101,19 @@
│ │ │ │ │     std::vector endpoints;
│ │ │ │ │     std::uint8_t ttiieerr  = 0;
│ │ │ │ │     std::uint8_t ffaaiill__lliimmiitt  = 0;
│ │ │ │ │     std::uint8_t source:4;
│ │ │ │ │     bool verified:1;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ~~aannnnoouunnccee__eennttrryy(()) aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ -~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +********** aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) ~~aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │  aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │  explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │  aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │  constructs a tracker announce _e_n_t_r_y with u as the URL.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennuumm ttrraacckkeerr__ssoouurrccee **********
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │   _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
│ │ │ │ │  |_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Utility.html
│ │ │ │ @@ -54,15 +54,15 @@
│ │ │ │  
    • hasher() operator=()
      • 
│ │ │ │  
    • update()
      • 
│ │ │ │  
    • final()
      • 
│ │ │ │  
    • reset()
      • 
│ │ │ │  
    
│ │ │ │  
    • 
│ │ │ │  
  • hasher256
│ │ │ │  
    • 
│ │ │ │  
│ │ │ │  
    
│ │ │ │ @@ -70,49 +70,49 @@
│ │ │ │  
    bitfield
    
│ │ │ │  
    Declared in "libtorrent/bitfield.hpp"
    
│ │ │ │  
    The bitfield type stores any number of bits as a bitfield
│ │ │ │  in a heap allocated array.
    
│ │ │ │  
    │ │ │ │  struct bitfield
│ │ │ │  {
│ │ │ │ -   bitfield (bitfield const& rhs);
│ │ │ │ -   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │     explicit bitfield (int bits);
│ │ │ │     bitfield (int bits, bool val);
│ │ │ │ -   bitfield (char const* b, int bits);
│ │ │ │ +   bitfield (bitfield const& rhs);
│ │ │ │     bitfield () noexcept = default;
│ │ │ │ +   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +   bitfield (char const* b, int bits);
│ │ │ │     void assign (char const* b, int const bits);
│ │ │ │     bool operator[] (int index) const noexcept;
│ │ │ │     bool get_bit (int index) const noexcept;
│ │ │ │ -   void clear_bit (int index) noexcept;
│ │ │ │     void set_bit (int index) noexcept;
│ │ │ │ +   void clear_bit (int index) noexcept;
│ │ │ │     bool all_set () const noexcept;
│ │ │ │     bool none_set () const noexcept;
│ │ │ │     int size () const noexcept;
│ │ │ │     int num_words () const noexcept;
│ │ │ │     int num_bytes () const noexcept;
│ │ │ │     bool empty () const noexcept;
│ │ │ │ -   char const* data () const noexcept;
│ │ │ │     char* data () noexcept;
│ │ │ │ +   char const* data () const noexcept;
│ │ │ │     void swap (bitfield& rhs) noexcept;
│ │ │ │     int count () const noexcept;
│ │ │ │     int find_first_set () const noexcept;
│ │ │ │     int find_last_clear () const noexcept;
│ │ │ │     bool operator== (lt::bitfield const& rhs) const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    bitfield()
    
│ │ │ │  
    │ │ │ │ -bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │  explicit bitfield (int bits);
│ │ │ │  bitfield (int bits, bool val);
│ │ │ │ -bitfield (char const* b, int bits);
│ │ │ │ +bitfield (bitfield const& rhs);
│ │ │ │  bitfield () noexcept = default;
│ │ │ │ +bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +bitfield (char const* b, int bits);
│ │ │ │  
    
│ │ │ │  
    constructs a new bitfield. The default constructor creates an empty
│ │ │ │  bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │  val is the value to initialize the bits to. If not specified
│ │ │ │  all bits are initialized to 0.
    
│ │ │ │  
    The constructor taking a pointer b and bits copies a bitfield
│ │ │ │  from the specified buffer, and bits number of bits (rounded up to
│ │ │ │ @@ -135,16 +135,16 @@
│ │ │ │  
│ │ │ │  
    query bit at index. Returns true if bit is 1, otherwise false.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    clear_bit() set_bit()
    
│ │ │ │  
    │ │ │ │ -void clear_bit (int index) noexcept;
│ │ │ │  void set_bit (int index) noexcept;
│ │ │ │ +void clear_bit (int index) noexcept;
│ │ │ │  
    
│ │ │ │  
    set bit at index to 0 (clear_bit) or 1 (set_bit).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    all_set()
    
│ │ │ │  
    │ │ │ │  bool all_set () const noexcept;
│ │ │ │ @@ -187,16 +187,16 @@
│ │ │ │  bool empty () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns true if the bitfield has zero size.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    data()
    
│ │ │ │  
    │ │ │ │ -char const* data () const noexcept;
│ │ │ │  char* data () noexcept;
│ │ │ │ +char const* data () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns a pointer to the internal buffer of the bitfield, or
│ │ │ │  nullptr if it's empty.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    swap()
    
│ │ │ │  
    │ │ │ │ @@ -242,41 +242,41 @@
│ │ │ │  
    The built-in software version of sha1-algorithm was implemented
│ │ │ │  by Steve Reid and released as public domain.
│ │ │ │  For more info, see src/sha1.cpp.
    
│ │ │ │  
    │ │ │ │  class hasher
│ │ │ │  {
│ │ │ │     hasher ();
│ │ │ │ -   hasher (hasher const&);
│ │ │ │ -   explicit hasher (span<char const> data);
│ │ │ │     hasher (char const* data, int len);
│ │ │ │ +   explicit hasher (span<char const> data);
│ │ │ │ +   hasher (hasher const&);
│ │ │ │     hasher& operator= (hasher const&) &;
│ │ │ │ -   hasher& update (span<char const> data);
│ │ │ │     hasher& update (char const* data, int len);
│ │ │ │ +   hasher& update (span<char const> data);
│ │ │ │     sha1_hash final ();
│ │ │ │     void reset ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    hasher() operator=()
    
│ │ │ │  
    │ │ │ │ -hasher (hasher const&);
│ │ │ │ -explicit hasher (span<char const> data);
│ │ │ │  hasher (char const* data, int len);
│ │ │ │ +explicit hasher (span<char const> data);
│ │ │ │ +hasher (hasher const&);
│ │ │ │  hasher& operator= (hasher const&) &;
│ │ │ │  
    
│ │ │ │  
    this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    update()
    
│ │ │ │  
    │ │ │ │ -hasher& update (span<char const> data);
│ │ │ │  hasher& update (char const* data, int len);
│ │ │ │ +hasher& update (span<char const> data);
│ │ │ │  
    
│ │ │ │  
    append the following bytes to what is being hashed
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    final()
    
│ │ │ │  
    │ │ │ │  sha1_hash final ();
│ │ │ │ @@ -296,33 +296,33 @@
│ │ │ │  
    
│ │ │ │  
    hasher256
    
│ │ │ │  
    Declared in "libtorrent/hasher.hpp"
    
│ │ │ │  
    │ │ │ │  class hasher256
│ │ │ │  {
│ │ │ │     hasher256 ();
│ │ │ │ -   hasher256 (hasher256 const&);
│ │ │ │ -   hasher256 (char const* data, int len);
│ │ │ │     hasher256& operator= (hasher256 const&) &;
│ │ │ │ +   hasher256 (char const* data, int len);
│ │ │ │     explicit hasher256 (span<char const> data);
│ │ │ │ +   hasher256 (hasher256 const&);
│ │ │ │     hasher256& update (span<char const> data);
│ │ │ │     hasher256& update (char const* data, int len);
│ │ │ │     sha256_hash final ();
│ │ │ │     void reset ();
│ │ │ │     ~hasher256 ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    hasher256() operator=()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    operator=() hasher256()
    
│ │ │ │  
    │ │ │ │ -hasher256 (hasher256 const&);
│ │ │ │ -hasher256 (char const* data, int len);
│ │ │ │  hasher256& operator= (hasher256 const&) &;
│ │ │ │ +hasher256 (char const* data, int len);
│ │ │ │  explicit hasher256 (span<char const> data);
│ │ │ │ +hasher256 (hasher256 const&);
│ │ │ │  
    
│ │ │ │  
    this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    update()
    
│ │ │ │  
    │ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -21,58 +21,58 @@
│ │ │ │ │            o _f_i_n_d___l_a_s_t___c_l_e_a_r_(_)
│ │ │ │ │      * _h_a_s_h_e_r
│ │ │ │ │            o _h_a_s_h_e_r_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │            o _u_p_d_a_t_e_(_)
│ │ │ │ │            o _f_i_n_a_l_(_)
│ │ │ │ │            o _r_e_s_e_t_(_)
│ │ │ │ │      * _h_a_s_h_e_r_2_5_6
│ │ │ │ │ -          o _h_a_s_h_e_r_2_5_6_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ +          o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_2_5_6_(_)
│ │ │ │ │            o _u_p_d_a_t_e_(_)
│ │ │ │ │            o _f_i_n_a_l_(_)
│ │ │ │ │            o _r_e_s_e_t_(_)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ bbiittffiieelldd ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_i_t_f_i_e_l_d_._h_p_p"
│ │ │ │ │  The _b_i_t_f_i_e_l_d type stores any number of bits as a _b_i_t_f_i_e_l_d in a heap allocated
│ │ │ │ │  array.
│ │ │ │ │  struct bitfield
│ │ │ │ │  {
│ │ │ │ │ -   bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -   bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │     explicit bbiittffiieelldd (int bits);
│ │ │ │ │     bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ -   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ +   bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │     bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +   bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │     void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │     bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │     bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ -   void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │     void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +   void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │     bool aallll__sseett () const noexcept;
│ │ │ │ │     bool nnoonnee__sseett () const noexcept;
│ │ │ │ │     int ssiizzee () const noexcept;
│ │ │ │ │     int nnuumm__wwoorrddss () const noexcept;
│ │ │ │ │     int nnuumm__bbyytteess () const noexcept;
│ │ │ │ │     bool eemmppttyy () const noexcept;
│ │ │ │ │ -   char const* ddaattaa () const noexcept;
│ │ │ │ │     char* ddaattaa () noexcept;
│ │ │ │ │ +   char const* ddaattaa () const noexcept;
│ │ │ │ │     void sswwaapp (bitfield& rhs) noexcept;
│ │ │ │ │     int ccoouunntt () const noexcept;
│ │ │ │ │     int ffiinndd__ffiirrsstt__sseett () const noexcept;
│ │ │ │ │     int ffiinndd__llaasstt__cclleeaarr () const noexcept;
│ │ │ │ │     bool ooppeerraattoorr==== (lt::bitfield const& rhs) const;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bbiittffiieelldd(()) **********
│ │ │ │ │ -bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │  explicit bbiittffiieelldd (int bits);
│ │ │ │ │  bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ -bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ +bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │  bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │  constructs a new _b_i_t_f_i_e_l_d. The default constructor creates an empty _b_i_t_f_i_e_l_d.
│ │ │ │ │  bits is the size of the _b_i_t_f_i_e_l_d (specified in bits). val is the value to
│ │ │ │ │  initialize the bits to. If not specified all bits are initialized to 0.
│ │ │ │ │  The constructor taking a pointer b and bits copies a _b_i_t_f_i_e_l_d from the
│ │ │ │ │  specified buffer, and bits number of bits (rounded up to the nearest byte
│ │ │ │ │  boundary).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -83,16 +83,16 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ooppeerraattoorr[[]](()) ggeett__bbiitt(()) **********
│ │ │ │ │  bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │  bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │  query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__bbiitt(()) sseett__bbiitt(()) **********
│ │ │ │ │ -void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │  void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │  set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aallll__sseett(()) **********
│ │ │ │ │  bool aallll__sseett () const noexcept;
│ │ │ │ │  returns true if all bits in the _b_i_t_f_i_e_l_d are set
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnoonnee__sseett(()) **********
│ │ │ │ │ @@ -113,16 +113,16 @@
│ │ │ │ │  returns the number of bytes needed to represent all bits in this _b_i_t_f_i_e_l_d
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eemmppttyy(()) **********
│ │ │ │ │  bool eemmppttyy () const noexcept;
│ │ │ │ │  returns true if the _b_i_t_f_i_e_l_d has zero size.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ddaattaa(()) **********
│ │ │ │ │ -char const* ddaattaa () const noexcept;
│ │ │ │ │  char* ddaattaa () noexcept;
│ │ │ │ │ +char const* ddaattaa () const noexcept;
│ │ │ │ │  returns a pointer to the internal buffer of the _b_i_t_f_i_e_l_d, or nullptr if it's
│ │ │ │ │  empty.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sswwaapp(()) **********
│ │ │ │ │  void sswwaapp (bitfield& rhs) noexcept;
│ │ │ │ │  swaps the bit-fields two variables refer to
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -151,35 +151,35 @@
│ │ │ │ │  If you want to reuse the _h_a_s_h_e_r object once you have created a hash, you have
│ │ │ │ │  to call reset() to reinitialize it.
│ │ │ │ │  The built-in software version of sha1-algorithm was implemented by Steve Reid
│ │ │ │ │  and released as public domain. For more info, see src/sha1.cpp.
│ │ │ │ │  class hasher
│ │ │ │ │  {
│ │ │ │ │     hhaasshheerr ();
│ │ │ │ │ -   hhaasshheerr (hasher const&);
│ │ │ │ │ -   explicit hhaasshheerr (span data);
│ │ │ │ │     hhaasshheerr (char const* data, int len);
│ │ │ │ │ +   explicit hhaasshheerr (span data);
│ │ │ │ │ +   hhaasshheerr (hasher const&);
│ │ │ │ │     hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ -   hasher& uuppddaattee (span data);
│ │ │ │ │     hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ +   hasher& uuppddaattee (span data);
│ │ │ │ │     sha1_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** hhaasshheerr(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -hhaasshheerr (hasher const&);
│ │ │ │ │ -explicit hhaasshheerr (span data);
│ │ │ │ │  hhaasshheerr (char const* data, int len);
│ │ │ │ │ +explicit hhaasshheerr (span data);
│ │ │ │ │ +hhaasshheerr (hasher const&);
│ │ │ │ │  hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │  this is the same as default constructing followed by a call to update(data,
│ │ │ │ │  len).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher& uuppddaattee (span data);
│ │ │ │ │  hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ +hasher& uuppddaattee (span data);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiinnaall(()) **********
│ │ │ │ │  sha1_hash ffiinnaall ();
│ │ │ │ │  returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │  _h_a_s_h_e_r constructor.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -189,30 +189,30 @@
│ │ │ │ │  constructed.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ hhaasshheerr225566 ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_h_a_s_h_e_r_._h_p_p"
│ │ │ │ │  class hasher256
│ │ │ │ │  {
│ │ │ │ │     hhaasshheerr225566 ();
│ │ │ │ │ -   hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -   hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │     hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ +   hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │     explicit hhaasshheerr225566 (span data);
│ │ │ │ │ +   hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │     hasher256& uuppddaattee (span data);
│ │ │ │ │     hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │     sha256_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │     ~~hhaasshheerr225566 ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshheerr225566(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +********** ooppeerraattoorr==(()) hhaasshheerr225566(()) **********
│ │ │ │ │  hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ +hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │  explicit hhaasshheerr225566 (span data);
│ │ │ │ │ +hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │  this is the same as default constructing followed by a call to update(data,
│ │ │ │ │  len).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** uuppddaattee(()) **********
│ │ │ │ │  hasher256& uuppddaattee (span data);
│ │ │ │ │  hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-ed25519.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -84,18 +84,18 @@
│ │ │ │  
    
│ │ │ │  
    Verifies the signature on the given message using pk
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    ed25519_add_scalar()
    
│ │ │ │  
    Declared in "libtorrent/kademlia/ed25519.hpp"
    
│ │ │ │  
    │ │ │ │ -public_key ed25519_add_scalar (public_key const& pk
│ │ │ │ -   , std::array<char, 32> const& scalar);
│ │ │ │  secret_key ed25519_add_scalar (secret_key const& sk
│ │ │ │     , std::array<char, 32> const& scalar);
│ │ │ │ +public_key ed25519_add_scalar (public_key const& pk
│ │ │ │ +   , std::array<char, 32> const& scalar);
│ │ │ │  
    
│ │ │ │  
    Adds a scalar to the given key pair where scalar is a 32 byte buffer
│ │ │ │  (possibly generated with ed25519_create_seed), generating a new key pair.
    
│ │ │ │  
    You can calculate the public key sum without knowing the private key and
│ │ │ │  vice versa by passing in null for the key you don't know. This is useful
│ │ │ │  when a third party (an authoritative server for example) needs to enforce
│ │ │ │  randomness on a key pair while only knowing the public key of the other
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -39,18 +39,18 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_e_d_2_5_5_1_9_._h_p_p"
│ │ │ │ │  bool eedd2255551199__vveerriiffyy (signature const& sig
│ │ │ │ │     , span msg, public_key const& pk);
│ │ │ │ │  Verifies the signature on the given message using pk
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ eedd2255551199__aadddd__ssccaallaarr(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_e_d_2_5_5_1_9_._h_p_p"
│ │ │ │ │ -public_key eedd2255551199__aadddd__ssccaallaarr (public_key const& pk
│ │ │ │ │ -   , std::array const& scalar);
│ │ │ │ │  secret_key eedd2255551199__aadddd__ssccaallaarr (secret_key const& sk
│ │ │ │ │     , std::array const& scalar);
│ │ │ │ │ +public_key eedd2255551199__aadddd__ssccaallaarr (public_key const& pk
│ │ │ │ │ +   , std::array const& scalar);
│ │ │ │ │  Adds a scalar to the given key pair where scalar is a 32 byte buffer (possibly
│ │ │ │ │  generated withed25519_create_seed), generating a new key pair.
│ │ │ │ │  You can calculate the public key sum without knowing the private key and vice
│ │ │ │ │  versa by passing in null for the key you don't know. This is useful when a
│ │ │ │ │  third party (an authoritative server for example) needs to enforce randomness
│ │ │ │ │  on a key pair while only knowing the public key of the other side.
│ │ │ │ │  Warning: the last bit of the scalar is ignored - if comparing scalars make sure
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -25,17 +25,17 @@
│ │ │ │  
    
│ │ │ │  
    Session
    
│ │ │ │  
    
│ │ │ │  
    session_params
    
│ │ │ │  
    session_proxy
    
│ │ │ │  
    session
    
│ │ │ │  
    session_handle
    
│ │ │ │ -
    write_session_params_buf()
    
│ │ │ │ -
    read_session_params()
    
│ │ │ │  
    write_session_params()
    
│ │ │ │ +
    read_session_params()
    
│ │ │ │ +
    write_session_params_buf()
    
│ │ │ │  
    
│ │ │ │  
    Torrent Info
    
│ │ │ │  
    
│ │ │ │  
    web_seed_entry
    
│ │ │ │  
    load_torrent_limits
    
│ │ │ │  
    torrent_info
    
│ │ │ │  
    
│ │ │ │ @@ -99,16 +99,16 @@
│ │ │ │  
    Settings
    
│ │ │ │  
    
│ │ │ │  
    overview
    
│ │ │ │  
    settings_pack
    
│ │ │ │  
    generate_fingerprint()
    
│ │ │ │  
    min_memory_usage()
    
│ │ │ │  
    high_performance_seed()
    
│ │ │ │ -
    setting_by_name()
    
│ │ │ │  
    name_for_setting()
    
│ │ │ │ +
    setting_by_name()
    
│ │ │ │  
    default_settings()
    
│ │ │ │  
    
│ │ │ │  
    DHT
    
│ │ │ │  
    
│ │ │ │  
    dht_state
    
│ │ │ │  
    dht_storage_counters
    
│ │ │ │  
    dht_storage_interface
    
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,17 +3,17 @@
│ │ │ │ │  ************ rreeffeerreennccee ddooccuummeennttaattiioonn ************
│ │ │ │ │  _s_i_n_g_l_e_-_p_a_g_e_ _v_e_r_s_i_o_n
│ │ │ │ │  Session
│ │ │ │ │  _s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ │  _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │  _s_e_s_s_i_o_n
│ │ │ │ │  _s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ │ -_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │ -_r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │  _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ +_r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ +_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │  Torrent Info
│ │ │ │ │  _w_e_b___s_e_e_d___e_n_t_r_y
│ │ │ │ │  _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │  _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │  Core
│ │ │ │ │  _p_e_e_r___i_n_f_o
│ │ │ │ │  _i_n_f_o___h_a_s_h___t
│ │ │ │ │ @@ -61,16 +61,16 @@
│ │ │ │ │  _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │  Settings
│ │ │ │ │  _o_v_e_r_v_i_e_w
│ │ │ │ │  _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │  _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_)
│ │ │ │ │  _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │  _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ -_s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │  _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ +_s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │  _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │  DHT
│ │ │ │ │  _d_h_t___s_t_a_t_e
│ │ │ │ │  _d_h_t___s_t_o_r_a_g_e___c_o_u_n_t_e_r_s
│ │ │ │ │  _d_h_t___s_t_o_r_a_g_e___i_n_t_e_r_f_a_c_e
│ │ │ │ │  _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │  _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/single-page-ref.html
│ │ │ │ @@ -55,15 +55,15 @@
│ │ │ │  
  • enum error_code_enum
    • 
│ │ │ │  
  • session_params
│ │ │ │  
    • 
│ │ │ │  
  • session_proxy
│ │ │ │  
    • 
│ │ │ │  
  • session
│ │ │ │  
    • 
│ │ │ │ -
  • read_session_params() write_session_params() write_session_params_buf()
    • 
│ │ │ │ +
  • write_session_params_buf() write_session_params() read_session_params()
    • 
│ │ │ │  
  • web_seed_entry
│ │ │ │  
    • 
│ │ │ │  
  • load_torrent_limits
    • 
│ │ │ │  
  • torrent_info
    • 
│ │ │ │  
    explicitly converts to true if this object represents an error, and
│ │ │ │  false if it does not.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    file()
    
│ │ │ │  
    │ │ │ │ -void file (file_index_t f);
│ │ │ │  file_index_t file () const;
│ │ │ │ +void file (file_index_t f);
│ │ │ │  
    
│ │ │ │  
    set and query the index (in the torrent) of the file this error
│ │ │ │  occurred on. This may also have special values defined in
│ │ │ │  torrent_status.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    ec
    
│ │ │ │  
    the error that occurred
    
│ │ │ │ @@ -2134,49 +2134,49 @@
│ │ │ │  
    session_params
    
│ │ │ │  
    Declared in "libtorrent/session_params.hpp"
    
│ │ │ │  
    The session_params is a parameters pack for configuring the session
│ │ │ │  before it's started.
    
│ │ │ │  
    │ │ │ │  struct session_params
│ │ │ │  {
│ │ │ │ -   session_params (settings_pack const& sp);
│ │ │ │ -   session_params ();
│ │ │ │     session_params (settings_pack&& sp);
│ │ │ │ -   session_params (settings_pack&& sp
│ │ │ │ -      , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ +   session_params ();
│ │ │ │ +   session_params (settings_pack const& sp);
│ │ │ │     session_params (settings_pack const& sp
│ │ │ │        , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ +   session_params (settings_pack&& sp
│ │ │ │ +      , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │  
│ │ │ │     settings_pack settings;
│ │ │ │     std::vector<std::shared_ptr<plugin>> extensions;
│ │ │ │     dht::dht_state dht_state;
│ │ │ │     dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │     disk_io_constructor_type disk_io_constructor;
│ │ │ │     std::map<std::string, std::string> ext_state;
│ │ │ │     libtorrent::ip_filter ip_filter;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    session_params()
    
│ │ │ │  
    │ │ │ │ -session_params (settings_pack const& sp);
│ │ │ │ -session_params ();
│ │ │ │  session_params (settings_pack&& sp);
│ │ │ │ +session_params ();
│ │ │ │ +session_params (settings_pack const& sp);
│ │ │ │  
    
│ │ │ │  
    This constructor can be used to start with the default plugins
│ │ │ │  (ut_metadata, ut_pex and smart_ban). Pass a settings_pack to set the
│ │ │ │  initial settings when the session starts.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    session_params()
    
│ │ │ │  
    │ │ │ │ -session_params (settings_pack&& sp
│ │ │ │ -      , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │  session_params (settings_pack const& sp
│ │ │ │        , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ +session_params (settings_pack&& sp
│ │ │ │ +      , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │  
    
│ │ │ │  
    This constructor helps to configure the set of initial plugins
│ │ │ │  to be added to the session before it's started.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    settings
    
│ │ │ │  
    The settings to configure the session with
    
│ │ │ │  
    
│ │ │ │ @@ -2218,33 +2218,33 @@
│ │ │ │  synchronize the completion of the shutdown. The lifetime of this object
│ │ │ │  may outlive session, causing the session destructor to not block. The
│ │ │ │  session_proxy destructor will block however, until the underlying session
│ │ │ │  is done shutting down.
    
│ │ │ │  
    │ │ │ │  struct session_proxy
│ │ │ │  {
│ │ │ │ +   session_proxy& operator= (session_proxy const&) &;
│ │ │ │     session_proxy (session_proxy&&) noexcept;
│ │ │ │ -   session_proxy (session_proxy const&);
│ │ │ │ +   session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │     ~session_proxy ();
│ │ │ │     session_proxy ();
│ │ │ │ -   session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ -   session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +   session_proxy (session_proxy const&);
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    operator=() ~session_proxy() session_proxy()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    ~session_proxy() operator=() session_proxy()
    
│ │ │ │  
    │ │ │ │ +session_proxy& operator= (session_proxy const&) &;
│ │ │ │  session_proxy (session_proxy&&) noexcept;
│ │ │ │ -session_proxy (session_proxy const&);
│ │ │ │ +session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │  ~session_proxy ();
│ │ │ │  session_proxy ();
│ │ │ │ -session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ -session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +session_proxy (session_proxy const&);
│ │ │ │  
    
│ │ │ │  
    default constructor, does not refer to any session
│ │ │ │  implementation object.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    session
    
│ │ │ │ @@ -2258,52 +2258,52 @@
│ │ │ │  session_handle::apply_settings() member function. To change one or more
│ │ │ │  configuration options, create a settings_pack. object and fill it with
│ │ │ │  the settings to be set and pass it in to session::apply_settings().
    
│ │ │ │  
    see apply_settings().
    
│ │ │ │  
    │ │ │ │  struct session : session_handle
│ │ │ │  {
│ │ │ │ -   session ();
│ │ │ │     explicit session (session_params&& params);
│ │ │ │ -   session (session_params const& params, session_flags_t flags);
│ │ │ │     session (session_params&& params, session_flags_t flags);
│ │ │ │ +   session ();
│ │ │ │     explicit session (session_params const& params);
│ │ │ │ -   session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ +   session (session_params const& params, session_flags_t flags);
│ │ │ │     session (session_params&& params, io_context& ios);
│ │ │ │ -   session (session_params const& params, io_context& ios);
│ │ │ │ +   session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │     session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +   session (session_params const& params, io_context& ios);
│ │ │ │     ~session ();
│ │ │ │     session_proxy abort ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    session()
    
│ │ │ │  
    │ │ │ │ -session ();
│ │ │ │  explicit session (session_params&& params);
│ │ │ │ -session (session_params const& params, session_flags_t flags);
│ │ │ │  session (session_params&& params, session_flags_t flags);
│ │ │ │ +session ();
│ │ │ │  explicit session (session_params const& params);
│ │ │ │ +session (session_params const& params, session_flags_t flags);
│ │ │ │  
    
│ │ │ │  
    Constructs the session objects which acts as the container of torrents.
│ │ │ │  In order to avoid a race condition between starting the session and
│ │ │ │  configuring it, you can pass in a session_params object. Its settings
│ │ │ │  will take effect before the session starts up.
    
│ │ │ │  
    The overloads taking flags can be used to start a session in
│ │ │ │  paused mode (by passing in session::paused). Note that
│ │ │ │  add_default_plugins do not have an affect on constructors that
│ │ │ │  take a session_params object. It already contains the plugins to use.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    session()
    
│ │ │ │  
    │ │ │ │ -session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │  session (session_params&& params, io_context& ios);
│ │ │ │ -session (session_params const& params, io_context& ios);
│ │ │ │ +session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │  session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params const& params, io_context& ios);
│ │ │ │  
    
│ │ │ │  
    Overload of the constructor that takes an external io_context to run
│ │ │ │  the session object on. This is primarily useful for tests that may want
│ │ │ │  to run multiple sessions on a single io_context, or low resource
│ │ │ │  systems where additional threads are expensive and sharing an
│ │ │ │  io_context with other events is fine.
    
│ │ │ │  
    
│ │ │ │ @@ -2366,27 +2366,27 @@
│ │ │ │        , status_flags_t flags = {}) const;
│ │ │ │     std::vector<torrent_status> get_torrent_status (
│ │ │ │        std::function<bool(torrent_status const&)> const& pred
│ │ │ │        , status_flags_t flags = {}) const;
│ │ │ │     void post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │ │     void post_session_stats ();
│ │ │ │     void post_dht_stats ();
│ │ │ │ -   void set_dht_state (dht::dht_state&& st);
│ │ │ │     void set_dht_state (dht::dht_state const& st);
│ │ │ │ +   void set_dht_state (dht::dht_state&& st);
│ │ │ │     torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │     std::vector<torrent_handle> get_torrents () const;
│ │ │ │     torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ -   torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ -   torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ -   void async_add_torrent (add_torrent_params&& params);
│ │ │ │     torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ +   void async_add_torrent (add_torrent_params&& params);
│ │ │ │     void async_add_torrent (add_torrent_params const& params);
│ │ │ │ -   void pause ();
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │     void resume ();
│ │ │ │     bool is_paused () const;
│ │ │ │ +   void pause ();
│ │ │ │     bool is_dht_running () const;
│ │ │ │     void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │     void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ │     void dht_get_item (sha1_hash const& target);
│ │ │ │     void dht_get_item (std::array<char, 32> key
│ │ │ │        , std::string salt = std::string());
│ │ │ │     sha1_hash dht_put_item (entry data);
│ │ │ │ @@ -2395,38 +2395,38 @@
│ │ │ │        , std::int64_t&, std::string const&)> cb
│ │ │ │        , std::string salt = std::string());
│ │ │ │     void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │     void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │     void dht_live_nodes (sha1_hash const& nid);
│ │ │ │     void dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ │     void dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ │ +   void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ -   void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     ip_filter get_ip_filter () const;
│ │ │ │     void set_ip_filter (ip_filter f);
│ │ │ │     void set_port_filter (port_filter const& f);
│ │ │ │ +   unsigned short listen_port () const;
│ │ │ │     unsigned short ssl_listen_port () const;
│ │ │ │     bool is_listening () const;
│ │ │ │ -   unsigned short listen_port () const;
│ │ │ │ -   void set_peer_class_filter (ip_filter const& f);
│ │ │ │     ip_filter get_peer_class_filter () const;
│ │ │ │ -   peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ +   void set_peer_class_filter (ip_filter const& f);
│ │ │ │     void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ +   peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │     peer_class_t create_peer_class (char const* name);
│ │ │ │     void delete_peer_class (peer_class_t cid);
│ │ │ │ -   peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │     void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ +   peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │     void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │ +   void apply_settings (settings_pack const&);
│ │ │ │     void apply_settings (settings_pack&&);
│ │ │ │     settings_pack get_settings () const;
│ │ │ │ -   void apply_settings (settings_pack const&);
│ │ │ │ -   void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ -   alert* wait_for_alert (time_duration max_wait);
│ │ │ │     void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ +   alert* wait_for_alert (time_duration max_wait);
│ │ │ │ +   void set_alert_notify (std::function<void()> const& fun);
│ │ │ │     void delete_port_mapping (port_mapping_t handle);
│ │ │ │     std::vector<port_mapping_t> add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │     void reopen_network_sockets (reopen_network_flags_t options = reopen_map_ports);
│ │ │ │     std::shared_ptr<aux::session_impl> native_handle () const;
│ │ │ │  
│ │ │ │     static constexpr save_state_flags_t save_settings  = 0_bit;
│ │ │ │     static constexpr save_state_flags_t save_dht_state  = 2_bit;
│ │ │ │ @@ -2541,16 +2541,16 @@
│ │ │ │  void post_dht_stats ();
│ │ │ │  
    
│ │ │ │  
    This will cause a dht_stats_alert to be posted.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    set_dht_state()
    
│ │ │ │  
    │ │ │ │ -void set_dht_state (dht::dht_state&& st);
│ │ │ │  void set_dht_state (dht::dht_state const& st);
│ │ │ │ +void set_dht_state (dht::dht_state&& st);
│ │ │ │  
    
│ │ │ │  
    set the DHT state for the session. This will be taken into account the
│ │ │ │  next time the DHT is started, as if it had been passed in via the
│ │ │ │  session_params on startup.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -2569,19 +2569,19 @@
│ │ │ │  torrents currently in the session.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    async_add_torrent() add_torrent()
    
│ │ │ │  
    │ │ │ │  torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ -torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ -torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ -void async_add_torrent (add_torrent_params&& params);
│ │ │ │  torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ │  void async_add_torrent (add_torrent_params const& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │  
    
│ │ │ │  
    You add torrents through the add_torrent() function where you give an
│ │ │ │  object with all the parameters. The add_torrent() overloads will block
│ │ │ │  until the torrent has been added (or failed to be added) and returns
│ │ │ │  an error code and a torrent_handle. In order to add torrents more
│ │ │ │  efficiently, consider using async_add_torrent() which returns
│ │ │ │  immediately, without waiting for the torrent to add. Notification of
│ │ │ │ @@ -2606,23 +2606,23 @@
│ │ │ │  want to control are torrent_flags::paused and
│ │ │ │  torrent_flags::auto_managed. In order to add a magnet link that will
│ │ │ │  just download the metadata, but no payload, set the
│ │ │ │  torrent_flags::upload_mode flag.
    
│ │ │ │  
    Special consideration has to be taken when adding hybrid torrents
│ │ │ │  (i.e. torrents that are BitTorrent v2 torrents that are backwards
│ │ │ │  compatible with v1). For more details, see BitTorrent v2 torrents.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    is_paused() resume() pause()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    resume() pause() is_paused()
    
│ │ │ │  
    │ │ │ │ -void pause ();
│ │ │ │  void resume ();
│ │ │ │  bool is_paused () const;
│ │ │ │ +void pause ();
│ │ │ │  
    
│ │ │ │  
    Pausing the session has the same effect as pausing every torrent in
│ │ │ │  it, except that torrents will not be resumed by the auto-manage
│ │ │ │  mechanism. Resuming will restore the torrents to their previous paused
│ │ │ │  state. i.e. the session pause state is separate from the torrent pause
│ │ │ │  state. A torrent is inactive if it is paused or if the session is
│ │ │ │  paused.
    
│ │ │ │ @@ -2730,18 +2730,18 @@
│ │ │ │  with the function object's context and make the function entirely
│ │ │ │  self-contained. The only reason data blob's value is computed
│ │ │ │  via a function instead of just passing in the new value is to avoid
│ │ │ │  race conditions. If you want to update the value in the DHT, you
│ │ │ │  must first retrieve it, then modify it, then write it back. The way
│ │ │ │  the DHT works, it is natural to always do a lookup before storing and
│ │ │ │  calling the callback in between is convenient.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    dht_get_peers() dht_announce()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    dht_announce() dht_get_peers()
    
│ │ │ │  
    │ │ │ │  void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │  void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │  
    
│ │ │ │  
    dht_get_peers() will issue a DHT get_peer request to the DHT for the
│ │ │ │  specified info-hash. The response (the peers) will be posted back in a
│ │ │ │  dht_get_peers_reply_alert.
    
│ │ │ │ @@ -2789,17 +2789,17 @@
│ │ │ │  with the response (if any) and the userdata pointer passed in here.
│ │ │ │  Since this alert is a response to an explicit call, it will always be
│ │ │ │  posted, regardless of the alert mask.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    add_extension()
    
│ │ │ │  
    │ │ │ │ +void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │  void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ -void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │  
    
│ │ │ │  
    This function adds an extension to this session. The argument is a
│ │ │ │  function object that is called with a torrent_handle and which should
│ │ │ │  return a std::shared_ptr<torrent_plugin>. To write custom
│ │ │ │  plugins, see libtorrent plugins. For the typical bittorrent client
│ │ │ │  all of these extensions should be added. The main plugins implemented
│ │ │ │  in libtorrent are:
    
│ │ │ │ @@ -2852,37 +2852,37 @@
│ │ │ │  
    │ │ │ │  void set_port_filter (port_filter const& f);
│ │ │ │  
    
│ │ │ │  
    apply port_filter f to incoming and outgoing peers. a port filter
│ │ │ │  will reject making outgoing peer connections to certain remote ports.
│ │ │ │  The main intention is to be able to avoid triggering certain
│ │ │ │  anti-virus software by connecting to SMTP, FTP ports.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    is_listening() ssl_listen_port() listen_port()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    ssl_listen_port() is_listening() listen_port()
    
│ │ │ │  
    │ │ │ │ +unsigned short listen_port () const;
│ │ │ │  unsigned short ssl_listen_port () const;
│ │ │ │  bool is_listening () const;
│ │ │ │ -unsigned short listen_port () const;
│ │ │ │  
    
│ │ │ │  
    is_listening() will tell you whether or not the session has
│ │ │ │  successfully opened a listening port. If it hasn't, this function will
│ │ │ │  return false, and then you can set a new
│ │ │ │  settings_pack::listen_interfaces to try another interface and port to
│ │ │ │  bind to.
    
│ │ │ │  
    listen_port() returns the port we ended up listening on.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    set_peer_class_filter() get_peer_class_filter()
    
│ │ │ │  
    │ │ │ │ -void set_peer_class_filter (ip_filter const& f);
│ │ │ │  ip_filter get_peer_class_filter () const;
│ │ │ │ +void set_peer_class_filter (ip_filter const& f);
│ │ │ │  
    
│ │ │ │  
    Sets the peer class filter for this session. All new peer connections
│ │ │ │  will take this into account and be added to the peer classes specified
│ │ │ │  by this filter, based on the peer's IP address.
    
│ │ │ │  
    The ip-filter essentially maps an IP -> uint32. Each bit in that 32
│ │ │ │  bit integer represents a peer class. The least significant bit
│ │ │ │  represents class 0, the next bit class 1 and so on.
    
│ │ │ │ @@ -2907,16 +2907,16 @@
│ │ │ │  
    The get_peer_class_filter() function returns the current filter.
    
│ │ │ │  
    For more information, see peer classes.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    get_peer_class_type_filter() set_peer_class_type_filter()
    
│ │ │ │  
    │ │ │ │ -peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │  void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ +peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │  
    
│ │ │ │  
    Sets and gets the peer class type filter. This is controls automatic
│ │ │ │  peer class assignments to peers based on what kind of socket it is.
    
│ │ │ │  
    It does not only support assigning peer classes, it also supports
│ │ │ │  removing peer classes based on socket type.
    
│ │ │ │  
    The order of these rules being applied are:
    
│ │ │ │  
      
│ │ │ │ @@ -2955,21 +2955,21 @@
│ │ │ │  remove the peer class if it's still assigned to torrents or peers. It
│ │ │ │  will however remove it once the last peer and torrent drops their
│ │ │ │  references to it.
      
│ │ │ │  
      There is no need to call this function for custom peer classes. All
│ │ │ │  peer classes will be properly destructed when the session object
│ │ │ │  destructs.
      
│ │ │ │  
      For more information on peer classes, see peer classes.
      
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_peer_class() get_peer_class()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_peer_class() set_peer_class()
    
│ │ │ │  
    │ │ │ │ -peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │  void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ +peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │  
    
│ │ │ │  
    These functions queries information from a peer class and updates the
│ │ │ │  configuration of a peer class, respectively.
    
│ │ │ │  
    cid must refer to an existing peer class. If it does not, the
│ │ │ │  return value of get_peer_class() is undefined.
    
│ │ │ │  
    set_peer_class() sets all the information in the
│ │ │ │  peer_class_info object in the specified peer class. There is no
│ │ │ │ @@ -3014,30 +3014,30 @@
│ │ │ │  advised to remove them from the back of the queue, to minimize the
│ │ │ │  shifting.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    apply_settings() get_settings()
    
│ │ │ │  
    │ │ │ │ +void apply_settings (settings_pack const&);
│ │ │ │  void apply_settings (settings_pack&&);
│ │ │ │  settings_pack get_settings () const;
│ │ │ │ -void apply_settings (settings_pack const&);
│ │ │ │  
    
│ │ │ │  
    Applies the settings specified by the settings_pack s. This is an
│ │ │ │  asynchronous operation that will return immediately and actually apply
│ │ │ │  the settings to the main thread of libtorrent some time later.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_alert_notify() pop_alerts() wait_for_alert()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    pop_alerts() set_alert_notify() wait_for_alert()
    
│ │ │ │  
    │ │ │ │ -void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ -alert* wait_for_alert (time_duration max_wait);
│ │ │ │  void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ +alert* wait_for_alert (time_duration max_wait);
│ │ │ │ +void set_alert_notify (std::function<void()> const& fun);
│ │ │ │  
    
│ │ │ │  
    Alerts is the main mechanism for libtorrent to report errors and
│ │ │ │  events. pop_alerts fills in the vector passed to it with pointers
│ │ │ │  to new alerts. The session still owns these alerts and they will stay
│ │ │ │  valid until the next time pop_alerts is called. You may not delete
│ │ │ │  the alert objects.
    
│ │ │ │  
    It is safe to call pop_alerts from multiple different threads, as
│ │ │ │ @@ -3163,30 +3163,30 @@
│ │ │ │  [report issue]
    
│ │ │ │  
    reopen_map_ports
    
│ │ │ │  
    This option indicates if the ports are mapped using natpmp
│ │ │ │  and upnp. If mapping was already made, they are deleted and added
│ │ │ │  again. This only works if natpmp and/or upnp are configured to be
│ │ │ │  enable.
    
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ +[report issue]
│ │ │ │  
│ │ │ │ -
    
│ │ │ │ -
    read_session_params() write_session_params() write_session_params_buf()
    
│ │ │ │ +
    
│ │ │ │ +
    write_session_params_buf() write_session_params() read_session_params()
    
│ │ │ │  
    Declared in "libtorrent/session_params.hpp"
    
│ │ │ │  
    │ │ │ │ -std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │ -   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ -entry write_session_params (session_params const& sp
│ │ │ │ -   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  session_params read_session_params (bdecode_node const& e
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  session_params read_session_params (span<char const> buf
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │ +   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +entry write_session_params (session_params const& sp
│ │ │ │ +   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  
    
│ │ │ │  
    These functions serialize and de-serialize a session_params object to and
│ │ │ │  from bencoded form. The session_params object is used to initialize a new
│ │ │ │  session using the state from a previous one (or by programmatically configure
│ │ │ │  the session up-front).
│ │ │ │  The flags parameter can be used to only save and load certain aspects of the
│ │ │ │  session's state.
│ │ │ │ @@ -3314,58 +3314,58 @@
│ │ │ │  
    
│ │ │ │  
    torrent_info
    
│ │ │ │  
    Declared in "libtorrent/torrent_info.hpp"
    
│ │ │ │  
    the torrent_info class holds the information found in a .torrent file.
    
│ │ │ │  
    │ │ │ │  class torrent_info
│ │ │ │  {
│ │ │ │ -   torrent_info (torrent_info const& t);
│ │ │ │ +   torrent_info (char const* buffer, int size);
│ │ │ │     explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -   torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -   torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │     torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -   torrent_info (char const* buffer, int size);
│ │ │ │ -   torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -   torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │     explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +   torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +   torrent_info (std::string const& filename, error_code& ec);
│ │ │ │     explicit torrent_info (std::string const& filename);
│ │ │ │ +   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ +   torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +   torrent_info (torrent_info const& t);
│ │ │ │     ~torrent_info ();
│ │ │ │     file_storage const& files () const;
│ │ │ │     file_storage const& orig_files () const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │     void remap_files (file_storage const& f);
│ │ │ │ -   void clear_trackers ();
│ │ │ │     std::vector<announce_entry> const& trackers () const;
│ │ │ │ +   void clear_trackers ();
│ │ │ │ +   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │     void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ -   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │     std::vector<std::string> collections () const;
│ │ │ │     std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ -   void add_http_seed (std::string const& url
│ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ +   std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ +   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │     void add_url_seed (std::string const& url
│ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ -   std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ -   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +   void add_http_seed (std::string const& url
│ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int piece_length () const;
│ │ │ │     int num_pieces () const;
│ │ │ │ +   int piece_length () const;
│ │ │ │     int blocks_per_piece () const;
│ │ │ │ -   piece_index_t end_piece () const;
│ │ │ │     index_range<piece_index_t> piece_range () const;
│ │ │ │     piece_index_t last_piece () const;
│ │ │ │ -   info_hash_t const& info_hashes () const;
│ │ │ │ +   piece_index_t end_piece () const;
│ │ │ │     sha1_hash info_hash () const noexcept;
│ │ │ │ -   bool v1 () const;
│ │ │ │ +   info_hash_t const& info_hashes () const;
│ │ │ │     bool v2 () const;
│ │ │ │ +   bool v1 () const;
│ │ │ │     int num_files () const;
│ │ │ │     std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ │        , std::int64_t offset, int size) const;
│ │ │ │     peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ │     string_view ssl_cert () const;
│ │ │ │     bool is_valid () const;
│ │ │ │     bool priv () const;
│ │ │ │ @@ -3386,27 +3386,27 @@
│ │ │ │     span<char const> piece_layer (file_index_t) const;
│ │ │ │     void free_piece_layers ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    torrent_info()
    
│ │ │ │  
    │ │ │ │ -torrent_info (torrent_info const& t);
│ │ │ │ +torrent_info (char const* buffer, int size);
│ │ │ │  explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │  torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (char const* buffer, int size);
│ │ │ │ -torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │  explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +torrent_info (std::string const& filename, error_code& ec);
│ │ │ │  explicit torrent_info (std::string const& filename);
│ │ │ │ +torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +torrent_info (torrent_info const& t);
│ │ │ │  
    
│ │ │ │  
    The constructor that takes an info-hash will initialize the info-hash
│ │ │ │  to the given value, but leave all other fields empty. This is used
│ │ │ │  internally when downloading torrents without the metadata. The
│ │ │ │  metadata will be created by libtorrent as soon as it has been
│ │ │ │  downloaded from the swarm.
    
│ │ │ │  
    The constructor that takes a bdecode_node will create a torrent_info
│ │ │ │ @@ -3435,18 +3435,18 @@
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    ~torrent_info()
    
│ │ │ │  
    │ │ │ │  ~torrent_info ();
│ │ │ │  
    
│ │ │ │  
    frees all storage associated with this torrent_info object
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    files() orig_files()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    orig_files() files()
    
│ │ │ │  
    │ │ │ │  file_storage const& files () const;
│ │ │ │  file_storage const& orig_files () const;
│ │ │ │  
    
│ │ │ │  
    The file_storage object contains the information on how to map the
│ │ │ │  pieces to files. It is separated from the torrent_info object because
│ │ │ │  when creating torrents a storage object needs to be created without
│ │ │ │ @@ -3493,25 +3493,25 @@
│ │ │ │  
    
│ │ │ │  
    Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │  instance, download all data in a torrent to a single file, or to a
│ │ │ │  number of fixed size sector aligned files, regardless of the number
│ │ │ │  and sizes of the files in the torrent.
    
│ │ │ │  
    The new specified file_storage must have the exact same size as
│ │ │ │  the current one.
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    trackers() clear_trackers() add_tracker()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_tracker() trackers() clear_trackers()
    
│ │ │ │  
    │ │ │ │ -void clear_trackers ();
│ │ │ │  std::vector<announce_entry> const& trackers () const;
│ │ │ │ +void clear_trackers ();
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │  void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │  
    
│ │ │ │  
    add_tracker() adds a tracker to the announce-list. The tier
│ │ │ │  determines the order in which the trackers are to be tried.
│ │ │ │  The trackers() function will return a sorted vector of
│ │ │ │  announce_entry. Each announce entry contains a string, which is
│ │ │ │  the tracker url, and a tier index. The tier index is the high-level
│ │ │ │  priority. No matter which trackers that works or not, the ones with
│ │ │ │ @@ -3528,29 +3528,29 @@
│ │ │ │  std::vector<sha1_hash> similar_torrents () const;
│ │ │ │  
│ │ │ │  
    These two functions are related to BEP 38 (mutable torrents). The
│ │ │ │  vectors returned from these correspond to the "similar" and
│ │ │ │  "collections" keys in the .torrent file. Both info-hashes and
│ │ │ │  collections from within the info-dict and from outside of it are
│ │ │ │  included.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_web_seeds() add_url_seed() add_http_seed() web_seeds()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_url_seed() add_http_seed() web_seeds() set_web_seeds()
    
│ │ │ │  
    │ │ │ │ -void add_http_seed (std::string const& url
│ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ +std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ +void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │  void add_url_seed (std::string const& url
│ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ -void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +void add_http_seed (std::string const& url
│ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │  
    
│ │ │ │  
    web_seeds() returns all url seeds and http seeds in the torrent.
│ │ │ │  Each entry is a web_seed_entry and may refer to either a url seed
│ │ │ │  or http seed.
    
│ │ │ │  
    add_url_seed() and add_http_seed() adds one url to the list of
│ │ │ │  url/http seeds.
    
│ │ │ │  
    set_web_seeds() replaces all web seeds with the ones specified in
│ │ │ │ @@ -3570,21 +3570,21 @@
│ │ │ │  std::int64_t total_size () const;
│ │ │ │  
│ │ │ │  
    total_size() returns the total number of bytes the torrent-file
│ │ │ │  represents. Note that this is the number of pieces times the piece
│ │ │ │  size (modulo the last piece possibly being smaller). With pad files,
│ │ │ │  the total size will be larger than the sum of all (regular) file
│ │ │ │  sizes.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    piece_length() num_pieces()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    num_pieces() piece_length()
    
│ │ │ │  
    │ │ │ │ -int piece_length () const;
│ │ │ │  int num_pieces () const;
│ │ │ │ +int piece_length () const;
│ │ │ │  
    
│ │ │ │  
    piece_length() and num_pieces() returns the number of byte
│ │ │ │  for each piece and the total number of pieces, respectively. The
│ │ │ │  difference between piece_size() and piece_length() is that
│ │ │ │  piece_size() takes the piece index as argument and gives you the
│ │ │ │  exact size of that piece. It will always be the same as
│ │ │ │  piece_length() except in the case of the last piece, which may be
│ │ │ │ @@ -3593,48 +3593,48 @@
│ │ │ │  
    
│ │ │ │  
    blocks_per_piece()
    
│ │ │ │  
    │ │ │ │  int blocks_per_piece () const;
│ │ │ │  
    
│ │ │ │  
    returns the number of blocks there are in the typical piece. There
│ │ │ │  may be fewer in the last piece)
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    last_piece() end_piece() piece_range()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    end_piece() last_piece() piece_range()
    
│ │ │ │  
    │ │ │ │ -piece_index_t end_piece () const;
│ │ │ │  index_range<piece_index_t> piece_range () const;
│ │ │ │  piece_index_t last_piece () const;
│ │ │ │ +piece_index_t end_piece () const;
│ │ │ │  
    
│ │ │ │  
    last_piece() returns the index to the last piece in the torrent and
│ │ │ │  end_piece() returns the index to the one-past-end piece in the
│ │ │ │  torrent
│ │ │ │  piece_range() returns an implementation-defined type that can be
│ │ │ │  used as the container in a range-for loop. Where the values are the
│ │ │ │  indices of all pieces in the file_storage.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    info_hashes() info_hash()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    info_hash() info_hashes()
    
│ │ │ │  
    │ │ │ │ -info_hash_t const& info_hashes () const;
│ │ │ │  sha1_hash info_hash () const noexcept;
│ │ │ │ +info_hash_t const& info_hashes () const;
│ │ │ │  
    
│ │ │ │  
    returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │  info_hashes() to get an object that may hold both a v1 and v2
│ │ │ │  info-hash
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    v1() v2()
    
│ │ │ │  
    │ │ │ │ -bool v1 () const;
│ │ │ │  bool v2 () const;
│ │ │ │ +bool v1 () const;
│ │ │ │  
    
│ │ │ │  
    returns whether this torrent has v1 and/or v2 metadata, respectively.
│ │ │ │  Hybrid torrents have both. These are shortcuts for
│ │ │ │  info_hashes().has_v1() and info_hashes().has_v2() calls.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    num_files()
    
│ │ │ │ @@ -4329,21 +4329,21 @@
│ │ │ │  
    Note
    
│ │ │ │  
    If has_v2() is false then the v1 hash might actually be a truncated
│ │ │ │  v2 hash
    
│ │ │ │  
    
│ │ │ │  
    │ │ │ │  struct info_hash_t
│ │ │ │  {
│ │ │ │ -   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -   info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │     info_hash_t () noexcept = default;
│ │ │ │     explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ +   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ +   info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ +   bool has (protocol_version v) const;
│ │ │ │     bool has_v1 () const;
│ │ │ │     bool has_v2 () const;
│ │ │ │ -   bool has (protocol_version v) const;
│ │ │ │     sha1_hash get (protocol_version v) const;
│ │ │ │     sha1_hash get_best () const;
│ │ │ │     friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │     friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept;
│ │ │ │     template <typename F> void for_each (F f) const;
│ │ │ │     bool operator< (info_hash_t const& o) const;
│ │ │ │     friend std::ostream& operator<< (std::ostream& os, info_hash_t const& ih);
│ │ │ │ @@ -4351,33 +4351,33 @@
│ │ │ │     sha1_hash v1;
│ │ │ │     sha256_hash v2;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    info_hash_t()
    
│ │ │ │  
    │ │ │ │ -explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │  info_hash_t () noexcept = default;
│ │ │ │  explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ +explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ +info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │  
    
│ │ │ │  
    The default constructor creates an object that has neither a v1 or v2
│ │ │ │  hash.
    
│ │ │ │  
    For backwards compatibility, make it possible to construct directly
│ │ │ │  from a v1 hash. This constructor allows implicit conversion from a
│ │ │ │  v1 hash, but the implicitness is deprecated.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    has() has_v2() has_v1()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    has_v2() has() has_v1()
    
│ │ │ │  
    │ │ │ │ +bool has (protocol_version v) const;
│ │ │ │  bool has_v1 () const;
│ │ │ │  bool has_v2 () const;
│ │ │ │ -bool has (protocol_version v) const;
│ │ │ │  
    
│ │ │ │  
    returns true if the corresponding info hash is present in this
│ │ │ │  object.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    get()
    
│ │ │ │  
    │ │ │ │ @@ -4407,16 +4407,16 @@
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    piece_block
    
│ │ │ │  
    Declared in "libtorrent/piece_block.hpp"
    
│ │ │ │  
    │ │ │ │  struct piece_block
│ │ │ │  {
│ │ │ │ -   piece_block (piece_index_t p_index, int b_index);
│ │ │ │     piece_block () = default;
│ │ │ │ +   piece_block (piece_index_t p_index, int b_index);
│ │ │ │     bool operator< (piece_block const& b) const;
│ │ │ │     bool operator== (piece_block const& b) const;
│ │ │ │     bool operator!= (piece_block const& b) const;
│ │ │ │  
│ │ │ │     static const piece_block invalid;
│ │ │ │     piece_index_t piece_index {0};
│ │ │ │     int block_index  = 0;
│ │ │ │ @@ -4461,26 +4461,26 @@
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    load_torrent_file() load_torrent_parsed() load_torrent_buffer()
    
│ │ │ │  
    Declared in "libtorrent/load_torrent.hpp"
    
│ │ │ │  
    │ │ │ │ +add_torrent_params load_torrent_parsed (
│ │ │ │ +   bdecode_node const& torrent_file);
│ │ │ │  add_torrent_params load_torrent_buffer (
│ │ │ │     span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_file (
│ │ │ │ -   std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │  add_torrent_params load_torrent_parsed (
│ │ │ │     bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │  add_torrent_params load_torrent_file (
│ │ │ │     std::string const& filename);
│ │ │ │ +add_torrent_params load_torrent_file (
│ │ │ │ +   std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │  add_torrent_params load_torrent_buffer (
│ │ │ │     span<char const> buffer);
│ │ │ │ -add_torrent_params load_torrent_parsed (
│ │ │ │ -   bdecode_node const& torrent_file);
│ │ │ │  
    
│ │ │ │  
    These functions load the content of a .torrent file into an
│ │ │ │  add_torrent_params object.
│ │ │ │  The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │  the ti field in the add_torrent_params object (as a torrent_info
│ │ │ │  object).
│ │ │ │  The returned object is suitable to be:
    
│ │ │ │ @@ -4493,16 +4493,16 @@
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    make_magnet_uri()
    
│ │ │ │  
    Declared in "libtorrent/magnet_uri.hpp"
    
│ │ │ │  
    │ │ │ │  std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │ -std::string make_magnet_uri (torrent_info const& info);
│ │ │ │  std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │ +std::string make_magnet_uri (torrent_info const& info);
│ │ │ │  
    
│ │ │ │  
    Generates a magnet URI from the specified torrent.
    
│ │ │ │  
    Several fields from the add_torrent_params objects are recorded in the
│ │ │ │  magnet link. In order to not include them, they have to be cleared before
│ │ │ │  calling make_magnet_uri(). These fields are used:
    
│ │ │ │  
    
│ │ │ │  ti, info_hashes, url_seeds, dht_nodes,
│ │ │ │ @@ -4522,17 +4522,17 @@
│ │ │ │  an empty string is returned.
    
│ │ │ │  
    For more information about magnet links, see magnet links.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    parse_magnet_uri()
    
│ │ │ │  
    Declared in "libtorrent/magnet_uri.hpp"
    
│ │ │ │  
    │ │ │ │ -add_torrent_params parse_magnet_uri (string_view uri, error_code& ec);
│ │ │ │ -add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │  void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ +add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │ +add_torrent_params parse_magnet_uri (string_view uri, error_code& ec);
│ │ │ │  
    
│ │ │ │  
    This function parses out information from the magnet link and populates the
│ │ │ │  add_torrent_params object. The overload that does not take an
│ │ │ │  error_code reference will throw a system_error on error
│ │ │ │  The overload taking an add_torrent_params reference will fill in the
│ │ │ │  fields specified in the magnet URI.
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -5377,18 +5377,18 @@
│ │ │ │  are supposed to return an instance of your peer_plugin class. Which in
│ │ │ │  turn will have its hook functions called on event specific to that peer.
    
│ │ │ │  
    The peer_connection_handle will be valid as long as the shared_ptr
│ │ │ │  is being held by the torrent object. So, it is generally a good idea to not
│ │ │ │  keep a shared_ptr to your own peer_plugin. If you want to keep references
│ │ │ │  to it, use weak_ptr.
    
│ │ │ │  
    If this function throws an exception, the connection will be closed.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    on_piece_pass() on_piece_failed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_piece_failed() on_piece_pass()
    
│ │ │ │  
    │ │ │ │  virtual void on_piece_pass (piece_index_t);
│ │ │ │  virtual void on_piece_failed (piece_index_t);
│ │ │ │  
    
│ │ │ │  
    These hooks are called when a piece passes the hash check or fails the hash
│ │ │ │  check, respectively. The index is the piece index that was downloaded.
│ │ │ │  It is possible to access the list of peers that participated in sending the
│ │ │ │ @@ -5397,18 +5397,18 @@
│ │ │ │  
    
│ │ │ │  
    tick()
    
│ │ │ │  
    │ │ │ │  virtual void tick ();
│ │ │ │  
    
│ │ │ │  
    This hook is called approximately once per second. It is a way of making it
│ │ │ │  easy for plugins to do timed events, for sending messages or whatever.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    on_resume() on_pause()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_pause() on_resume()
    
│ │ │ │  
    │ │ │ │  virtual bool on_resume ();
│ │ │ │  virtual bool on_pause ();
│ │ │ │  
    
│ │ │ │  
    These hooks are called when the torrent is paused and resumed respectively.
│ │ │ │  The return value indicates if the event was handled. A return value of
│ │ │ │  true indicates that it was handled, and no other plugin after this one
│ │ │ │ @@ -5476,43 +5476,43 @@
│ │ │ │  {
│ │ │ │     virtual string_view type () const;
│ │ │ │     virtual void add_handshake (entry&);
│ │ │ │     virtual void on_disconnect (error_code const&);
│ │ │ │     virtual void on_connected ();
│ │ │ │     virtual bool on_handshake (span<char const>);
│ │ │ │     virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │ -   virtual bool on_not_interested ();
│ │ │ │     virtual bool on_unchoke ();
│ │ │ │ -   virtual bool on_have_all ();
│ │ │ │ -   virtual bool on_dont_have (piece_index_t);
│ │ │ │     virtual bool on_have_none ();
│ │ │ │ -   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +   virtual bool on_interested ();
│ │ │ │ +   virtual bool on_dont_have (piece_index_t);
│ │ │ │     virtual bool on_choke ();
│ │ │ │ +   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +   virtual bool on_have_all ();
│ │ │ │     virtual bool on_have (piece_index_t);
│ │ │ │ +   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │     virtual bool on_request (peer_request const&);
│ │ │ │ -   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -   virtual bool on_interested ();
│ │ │ │ +   virtual bool on_not_interested ();
│ │ │ │     virtual bool on_piece (peer_request const& /*piece*/
│ │ │ │        , span<char const> /*buf*/);
│ │ │ │     virtual bool on_reject (peer_request const&);
│ │ │ │ -   virtual bool on_cancel (peer_request const&);
│ │ │ │     virtual bool on_suggest (piece_index_t);
│ │ │ │ +   virtual bool on_cancel (peer_request const&);
│ │ │ │ +   virtual void sent_suggest (piece_index_t);
│ │ │ │ +   virtual void sent_reject_request (peer_request const&);
│ │ │ │ +   virtual void sent_request (peer_request const&);
│ │ │ │     virtual void sent_have_none ();
│ │ │ │ +   virtual void sent_have_all ();
│ │ │ │     virtual void sent_cancel (peer_request const&);
│ │ │ │     virtual void sent_choke ();
│ │ │ │ -   virtual void sent_request (peer_request const&);
│ │ │ │ -   virtual void sent_suggest (piece_index_t);
│ │ │ │ -   virtual void sent_have_all ();
│ │ │ │     virtual void sent_allow_fast (piece_index_t);
│ │ │ │ -   virtual void sent_reject_request (peer_request const&);
│ │ │ │ -   virtual void sent_unchoke ();
│ │ │ │ -   virtual void sent_have (piece_index_t);
│ │ │ │     virtual void sent_not_interested ();
│ │ │ │ -   virtual void sent_piece (peer_request const&);
│ │ │ │     virtual void sent_interested ();
│ │ │ │ +   virtual void sent_have (piece_index_t);
│ │ │ │ +   virtual void sent_piece (peer_request const&);
│ │ │ │ +   virtual void sent_unchoke ();
│ │ │ │     virtual void sent_payload (int /* bytes */);
│ │ │ │     virtual bool can_disconnect (error_code const& /*ec*/);
│ │ │ │     virtual bool on_extended (int /*length*/, int /*msg*/,
│ │ │ │        span<char const> /*body*/);
│ │ │ │     virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │        span<char const> /*body*/);
│ │ │ │     virtual void on_piece_pass (piece_index_t);
│ │ │ │ @@ -5570,39 +5570,39 @@
│ │ │ │  virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │  
│ │ │ │  
    called when the extension handshake from the other end is received
│ │ │ │  if this returns false, it means that this extension isn't
│ │ │ │  supported by this peer. It will result in this peer_plugin
│ │ │ │  being removed from the peer_connection and destructed.
│ │ │ │  this is not called for web seeds
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    on_not_interested() on_have_all() on_have() on_bitfield() on_dont_have() on_have_none() on_allowed_fast() on_unchoke() on_choke() on_interested() on_request()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_dont_have() on_unchoke() on_bitfield() on_have() on_have_all() on_not_interested() on_have_none() on_choke() on_interested() on_request() on_allowed_fast()
    
│ │ │ │  
    │ │ │ │ -virtual bool on_not_interested ();
│ │ │ │  virtual bool on_unchoke ();
│ │ │ │ -virtual bool on_have_all ();
│ │ │ │ -virtual bool on_dont_have (piece_index_t);
│ │ │ │  virtual bool on_have_none ();
│ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +virtual bool on_interested ();
│ │ │ │ +virtual bool on_dont_have (piece_index_t);
│ │ │ │  virtual bool on_choke ();
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +virtual bool on_have_all ();
│ │ │ │  virtual bool on_have (piece_index_t);
│ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │  virtual bool on_request (peer_request const&);
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -virtual bool on_interested ();
│ │ │ │ +virtual bool on_not_interested ();
│ │ │ │  
    
│ │ │ │  
    returning true from any of the message handlers
│ │ │ │  indicates that the plugin has handled the message.
│ │ │ │  it will break the plugin chain traversing and not let
│ │ │ │  anyone else handle the message, including the default
│ │ │ │  handler.
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -5614,27 +5614,27 @@
│ │ │ │  
│ │ │ │  
    This function is called when the peer connection is receiving
│ │ │ │  a piece. buf points (non-owning pointer) to the data in an
│ │ │ │  internal immutable disk buffer. The length of the data is specified
│ │ │ │  in the length member of the piece parameter.
│ │ │ │  returns true to indicate that the piece is handled and the
│ │ │ │  rest of the logic should be ignored.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ +
│ │ │ │  
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    sent_unchoke() sent_have() sent_piece() sent_not_interested() sent_interested()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    sent_have() sent_unchoke() sent_piece() sent_not_interested() sent_interested()
    
│ │ │ │  
    │ │ │ │ -virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_have (piece_index_t);
│ │ │ │  virtual void sent_not_interested ();
│ │ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ │  virtual void sent_interested ();
│ │ │ │ +virtual void sent_have (piece_index_t);
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │ +virtual void sent_unchoke ();
│ │ │ │  
    
│ │ │ │  
    called after a choke message has been sent to the peer
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    sent_payload()
    
│ │ │ │  
    │ │ │ │  virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -5670,18 +5670,18 @@
│ │ │ │  
    
│ │ │ │  
    on_unknown_message()
    
│ │ │ │  
    │ │ │ │  virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │        span<char const> /*body*/);
│ │ │ │  
    
│ │ │ │  
    this is not called for web seeds
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    on_piece_pass() on_piece_failed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_piece_failed() on_piece_pass()
    
│ │ │ │  
    │ │ │ │  virtual void on_piece_pass (piece_index_t);
│ │ │ │  virtual void on_piece_failed (piece_index_t);
│ │ │ │  
    
│ │ │ │  
    called when a piece that this peer participated in either
│ │ │ │  fails or passes the hash_check
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -5704,16 +5704,16 @@
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    crypto_plugin
    
│ │ │ │  
    Declared in "libtorrent/extensions.hpp"
    
│ │ │ │  
    │ │ │ │  struct crypto_plugin
│ │ │ │  {
│ │ │ │ -   virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │     virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │ +   virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │     encrypt (span<span<char>> /*send_vec*/) = 0;
│ │ │ │     virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    decrypt()
    
│ │ │ │  
    │ │ │ │ @@ -5743,18 +5743,18 @@
│ │ │ │     connection_type type () const;
│ │ │ │     void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │     peer_plugin const* find_plugin (string_view type) const;
│ │ │ │     bool is_seed () const;
│ │ │ │     bool upload_only () const;
│ │ │ │     peer_id const& pid () const;
│ │ │ │     bool has_piece (piece_index_t i) const;
│ │ │ │ -   bool is_choked () const;
│ │ │ │     bool is_interesting () const;
│ │ │ │ -   bool has_peer_choked () const;
│ │ │ │ +   bool is_choked () const;
│ │ │ │     bool is_peer_interested () const;
│ │ │ │ +   bool has_peer_choked () const;
│ │ │ │     void choke_this_peer ();
│ │ │ │     void maybe_unchoke_this_peer ();
│ │ │ │     void get_peer_info (peer_info& p) const;
│ │ │ │     torrent_handle associated_torrent () const;
│ │ │ │     tcp::endpoint const& remote () const;
│ │ │ │     tcp::endpoint local_endpoint () const;
│ │ │ │     bool is_outgoing () const;
│ │ │ │ @@ -5770,17 +5770,17 @@
│ │ │ │        , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT(4,5);
│ │ │ │     bool can_disconnect (error_code const& ec) const;
│ │ │ │     bool has_metadata () const;
│ │ │ │     bool in_handshake () const;
│ │ │ │     void send_buffer (char const* begin, int size);
│ │ │ │     time_point time_of_last_unchoke () const;
│ │ │ │     std::time_t last_seen_complete () const;
│ │ │ │ +   bool operator< (peer_connection_handle const& o) const;
│ │ │ │     bool operator!= (peer_connection_handle const& o) const;
│ │ │ │     bool operator== (peer_connection_handle const& o) const;
│ │ │ │ -   bool operator< (peer_connection_handle const& o) const;
│ │ │ │     std::shared_ptr<peer_connection> native_handle () const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    bt_peer_connection_handle
    
│ │ │ │  
    Declared in "libtorrent/peer_connection_handle.hpp"
    
│ │ │ │ @@ -5790,16 +5790,16 @@
│ │ │ │  
    │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │  {
│ │ │ │     explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │     bool support_extensions () const;
│ │ │ │     bool packet_finished () const;
│ │ │ │     bool supports_encryption () const;
│ │ │ │ -   void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │     void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ +   void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │     std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    create_ut_pex_plugin()
    
│ │ │ │  
    Declared in "libtorrent/extensions/ut_pex.hpp"
    
│ │ │ │ @@ -5879,70 +5879,70 @@
│ │ │ │  size. Everything necessary to interpret a regular bittorrent storage
│ │ │ │  file structure.
    
│ │ │ │  
    │ │ │ │  class file_storage
│ │ │ │  {
│ │ │ │     bool is_valid () const;
│ │ │ │     void reserve (int num_files);
│ │ │ │ -   void add_file_borrow (string_view filename
│ │ │ │ -      , std::string const& path, std::int64_t file_size
│ │ │ │ -      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ -      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │     void add_file_borrow (error_code& ec, string_view filename
│ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │     void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}
│ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │     void add_file (std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}
│ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ +   void add_file_borrow (string_view filename
│ │ │ │ +      , std::string const& path, std::int64_t file_size
│ │ │ │ +      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ +      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │     void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │     std::vector<file_slice> map_block (piece_index_t piece, std::int64_t offset
│ │ │ │        , std::int64_t size) const;
│ │ │ │     peer_request map_file (file_index_t file, std::int64_t offset, int size) const;
│ │ │ │     int num_files () const noexcept;
│ │ │ │     file_index_t end_file () const noexcept;
│ │ │ │     index_range<file_index_t> file_range () const noexcept;
│ │ │ │     std::int64_t total_size () const;
│ │ │ │     int num_pieces () const;
│ │ │ │     void set_num_pieces (int n);
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │     piece_index_t last_piece () const;
│ │ │ │     index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │ -   int piece_length () const;
│ │ │ │     void set_piece_length (int l);
│ │ │ │ +   int piece_length () const;
│ │ │ │     int piece_size (piece_index_t index) const;
│ │ │ │     int piece_size2 (piece_index_t index) const;
│ │ │ │     int blocks_in_piece2 (piece_index_t index) const;
│ │ │ │     int blocks_per_piece () const;
│ │ │ │     std::string const& name () const;
│ │ │ │     void set_name (std::string const& n);
│ │ │ │     void swap (file_storage& ti) noexcept;
│ │ │ │     void canonicalize ();
│ │ │ │ -   char const* root_ptr (file_index_t const index) const;
│ │ │ │ -   std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ -   std::time_t mtime (file_index_t index) const;
│ │ │ │ +   string_view file_name (file_index_t index) const;
│ │ │ │     sha1_hash hash (file_index_t index) const;
│ │ │ │ +   bool pad_file_at (file_index_t index) const;
│ │ │ │ +   std::int64_t file_offset (file_index_t index) const;
│ │ │ │     sha256_hash root (file_index_t index) const;
│ │ │ │     std::int64_t file_size (file_index_t index) const;
│ │ │ │ -   std::int64_t file_offset (file_index_t index) const;
│ │ │ │ -   string_view file_name (file_index_t index) const;
│ │ │ │ +   char const* root_ptr (file_index_t const index) const;
│ │ │ │ +   std::time_t mtime (file_index_t index) const;
│ │ │ │ +   std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │     std::string symlink (file_index_t index) const;
│ │ │ │ -   bool pad_file_at (file_index_t index) const;
│ │ │ │     int file_num_blocks (file_index_t index) const;
│ │ │ │ -   index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │     int file_num_pieces (file_index_t index) const;
│ │ │ │ -   int file_first_block_node (file_index_t index) const;
│ │ │ │ +   index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │     int file_first_piece_node (file_index_t index) const;
│ │ │ │ +   int file_first_block_node (file_index_t index) const;
│ │ │ │     std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │     void all_path_hashes (std::unordered_set<std::uint32_t>& table) const;
│ │ │ │     file_flags_t file_flags (file_index_t index) const;
│ │ │ │     bool file_absolute_path (file_index_t index) const;
│ │ │ │     file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │     file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │     file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ @@ -5970,37 +5970,37 @@
│ │ │ │  
    reserve()
    
│ │ │ │  
    │ │ │ │  void reserve (int num_files);
│ │ │ │  
    
│ │ │ │  
    allocates space for num_files in the internal file list. This can
│ │ │ │  be used to avoid reallocating the internal file list when the number
│ │ │ │  of files to be added is known up-front.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    add_file() add_file_borrow()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_file_borrow() add_file()
    
│ │ │ │  
    │ │ │ │ -void add_file_borrow (string_view filename
│ │ │ │ -      , std::string const& path, std::int64_t file_size
│ │ │ │ -      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ -      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │  void add_file_borrow (error_code& ec, string_view filename
│ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │  void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}
│ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │  void add_file (std::string const& path, std::int64_t file_size
│ │ │ │        , file_flags_t file_flags = {}
│ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ +void add_file_borrow (string_view filename
│ │ │ │ +      , std::string const& path, std::int64_t file_size
│ │ │ │ +      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ +      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │  
    
│ │ │ │  
    Adds a file to the file storage. The add_file_borrow version
│ │ │ │  expects that filename is the file name (without a path) of
│ │ │ │  the file that's being added.
│ │ │ │  This memory is borrowed, i.e. it is the caller's
│ │ │ │  responsibility to make sure it stays valid throughout the lifetime
│ │ │ │  of this file_storage object or any copy of it. The same thing applies
│ │ │ │ @@ -6098,18 +6098,18 @@
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    total_size()
    
│ │ │ │  
    │ │ │ │  std::int64_t total_size () const;
│ │ │ │  
    
│ │ │ │  
    returns the total number of bytes all the files in this torrent spans
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    num_pieces() set_num_pieces()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_num_pieces() num_pieces()
    
│ │ │ │  
    │ │ │ │  int num_pieces () const;
│ │ │ │  void set_num_pieces (int n);
│ │ │ │  
    
│ │ │ │  
    set and get the number of pieces in the torrent
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -6132,21 +6132,21 @@
│ │ │ │  
    piece_range()
    
│ │ │ │  
    │ │ │ │  index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns an implementation-defined type that can be used as the
│ │ │ │  container in a range-for loop. Where the values are the indices of all
│ │ │ │  pieces in the file_storage.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    piece_length() set_piece_length()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_piece_length() piece_length()
    
│ │ │ │  
    │ │ │ │ -int piece_length () const;
│ │ │ │  void set_piece_length (int l);
│ │ │ │ +int piece_length () const;
│ │ │ │  
    
│ │ │ │  
    set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │  and at least 16 kiB.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    piece_size()
    
│ │ │ │  
    │ │ │ │ @@ -6200,37 +6200,37 @@
│ │ │ │  
    
│ │ │ │  
    canonicalize()
    
│ │ │ │  
    │ │ │ │  void canonicalize ();
│ │ │ │  
    
│ │ │ │  
    arrange files and padding to match the canonical form required
│ │ │ │  by BEP 52
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │  
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │ -
    
│ │ │ │ -
    file_num_blocks() file_num_pieces() file_piece_range()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_piece_range() file_num_blocks() file_num_pieces()
    
│ │ │ │  
    │ │ │ │  int file_num_blocks (file_index_t index) const;
│ │ │ │ -index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │  int file_num_pieces (file_index_t index) const;
│ │ │ │ +index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │  
    
│ │ │ │  
    Returns the number of pieces or blocks the file at index spans,
│ │ │ │  under the assumption that the file is aligned to the start of a piece.
│ │ │ │  This is only meaningful for v2 torrents, where files are guaranteed
│ │ │ │  such alignment.
│ │ │ │  These numbers are used to size and navigate the merkle hash tree for
│ │ │ │  each file.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    file_first_piece_node() file_first_block_node()
    
│ │ │ │  
    │ │ │ │ -int file_first_block_node (file_index_t index) const;
│ │ │ │  int file_first_piece_node (file_index_t index) const;
│ │ │ │ +int file_first_block_node (file_index_t index) const;
│ │ │ │  
    
│ │ │ │  
    index of first piece node in the merkle tree
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    file_path_hash()
    
│ │ │ │  
    │ │ │ │  std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │ @@ -6309,18 +6309,18 @@
│ │ │ │  
    file_absolute_path()
    
│ │ │ │  
    │ │ │ │  bool file_absolute_path (file_index_t index) const;
│ │ │ │  
    
│ │ │ │  
    returns true if the file at the specified index has been renamed to
│ │ │ │  have an absolute path, i.e. is not anchored in the save path of the
│ │ │ │  torrent.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    file_index_at_piece() file_index_at_offset()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_index_at_offset() file_index_at_piece()
    
│ │ │ │  
    │ │ │ │  file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │  file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │  
    
│ │ │ │  
    returns the index of the file at the given offset in the torrent
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -6568,40 +6568,40 @@
│ │ │ │  requiring the same type be requested out of it as was assigned to it.
    
│ │ │ │  
    │ │ │ │  struct client_data_t
│ │ │ │  {
│ │ │ │     client_data_t () = default;
│ │ │ │     explicit client_data_t (T* v);
│ │ │ │     client_data_t& operator= (T* v);
│ │ │ │ -   explicit operator T () const;
│ │ │ │     T* get () const;
│ │ │ │ -   operator void const* () const = delete;
│ │ │ │ -   operator void* () const = delete;
│ │ │ │ +   explicit operator T () const;
│ │ │ │     client_data_t& operator= (void const*) = delete;
│ │ │ │     client_data_t& operator= (void*) = delete;
│ │ │ │ +   operator void* () const = delete;
│ │ │ │ +   operator void const* () const = delete;
│ │ │ │  
│ │ │ │     template <typename T, typename U  = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    client_data_t()
    
│ │ │ │  
    │ │ │ │  client_data_t () = default;
│ │ │ │  
    
│ │ │ │  
    construct a nullptr client data
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    operator=() const*() void*()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    void*() operator=() const*()
    
│ │ │ │  
    │ │ │ │ -operator void const* () const = delete;
│ │ │ │ -operator void* () const = delete;
│ │ │ │  client_data_t& operator= (void const*) = delete;
│ │ │ │  client_data_t& operator= (void*) = delete;
│ │ │ │ +operator void* () const = delete;
│ │ │ │ +operator void const* () const = delete;
│ │ │ │  
    
│ │ │ │  
    we don't allow type-unsafe operations
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    add_torrent_params
    
│ │ │ │  
    Declared in "libtorrent/add_torrent_params.hpp"
    
│ │ │ │ @@ -7089,16 +7089,16 @@
│ │ │ │  
    block_info
    
│ │ │ │  
    Declared in "libtorrent/torrent_handle.hpp"
    
│ │ │ │  
    holds the state of a block in a piece. Who we requested
│ │ │ │  it from and how far along we are at downloading it.
    
│ │ │ │  
    │ │ │ │  struct block_info
│ │ │ │  {
│ │ │ │ -   tcp::endpoint peer () const;
│ │ │ │     void set_peer (tcp::endpoint const& ep);
│ │ │ │ +   tcp::endpoint peer () const;
│ │ │ │  
│ │ │ │     enum block_state_t
│ │ │ │     {
│ │ │ │        none,
│ │ │ │        requested,
│ │ │ │        writing,
│ │ │ │        finished,
│ │ │ │ @@ -7110,16 +7110,16 @@
│ │ │ │     unsigned num_peers:14;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    peer() set_peer()
    
│ │ │ │  
    │ │ │ │ -tcp::endpoint peer () const;
│ │ │ │  void set_peer (tcp::endpoint const& ep);
│ │ │ │ +tcp::endpoint peer () const;
│ │ │ │  
    
│ │ │ │  
    The peer is the ip address of the peer this block was downloaded from.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    enum block_state_t
    
│ │ │ │  
    Declared in "libtorrent/torrent_handle.hpp"
    
│ │ │ │  
    
│ │ │ │ @@ -7264,104 +7264,104 @@
│ │ │ │     torrent_handle () noexcept = default;
│ │ │ │     void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │     void read_piece (piece_index_t piece) const;
│ │ │ │     bool have_piece (piece_index_t piece) const;
│ │ │ │     void post_peer_info () const;
│ │ │ │     void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ -   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │     void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │     void post_download_queue () const;
│ │ │ │ -   void reset_piece_deadline (piece_index_t index) const;
│ │ │ │     void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +   void reset_piece_deadline (piece_index_t index) const;
│ │ │ │     void clear_piece_deadlines () const;
│ │ │ │ -   std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │     void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +   std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │     void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │     std::vector<open_file_state> file_status () const;
│ │ │ │     void clear_error () const;
│ │ │ │ -   void post_trackers () const;
│ │ │ │     void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ -   void add_tracker (announce_entry const&) const;
│ │ │ │     std::vector<announce_entry> trackers () const;
│ │ │ │ +   void add_tracker (announce_entry const&) const;
│ │ │ │ +   void post_trackers () const;
│ │ │ │     void remove_url_seed (std::string const& url) const;
│ │ │ │ -   void add_url_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> url_seeds () const;
│ │ │ │ +   void add_url_seed (std::string const& url) const;
│ │ │ │     void remove_http_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> http_seeds () const;
│ │ │ │     void add_http_seed (std::string const& url) const;
│ │ │ │     void add_extension (
│ │ │ │        std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │        , client_data_t userdata = client_data_t{});
│ │ │ │     bool set_metadata (span<char const> metadata) const;
│ │ │ │     bool is_valid () const;
│ │ │ │ -   void resume () const;
│ │ │ │     void pause (pause_flags_t flags = {}) const;
│ │ │ │ -   torrent_flags_t flags () const;
│ │ │ │ -   void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +   void resume () const;
│ │ │ │     void unset_flags (torrent_flags_t flags) const;
│ │ │ │     void set_flags (torrent_flags_t flags) const;
│ │ │ │ +   torrent_flags_t flags () const;
│ │ │ │ +   void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │     void flush_cache () const;
│ │ │ │     void force_recheck () const;
│ │ │ │     void save_resume_data (resume_data_flags_t flags = {}) const;
│ │ │ │ -   bool need_save_resume_data () const;
│ │ │ │     bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ -   void queue_position_up () const;
│ │ │ │ +   bool need_save_resume_data () const;
│ │ │ │     void queue_position_bottom () const;
│ │ │ │ +   void queue_position_up () const;
│ │ │ │     void queue_position_down () const;
│ │ │ │ -   queue_position_t queue_position () const;
│ │ │ │     void queue_position_top () const;
│ │ │ │ +   queue_position_t queue_position () const;
│ │ │ │     void queue_position_set (queue_position_t p) const;
│ │ │ │ -   void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ -      , std::string const& private_key
│ │ │ │ -      , std::string const& dh_params);
│ │ │ │     void set_ssl_certificate (std::string const& certificate
│ │ │ │        , std::string const& private_key
│ │ │ │        , std::string const& dh_params
│ │ │ │        , std::string const& passphrase = "");
│ │ │ │ -   std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ +   void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ +      , std::string const& private_key
│ │ │ │ +      , std::string const& dh_params);
│ │ │ │     std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ +   std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │     std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │     void post_piece_availability () const;
│ │ │ │     void piece_availability (std::vector<int>& avail) const;
│ │ │ │     void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +   void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +   void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │     std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │     download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ -   void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ -   void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │     void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │     std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ -   void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │     download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -   void force_dht_announce () const;
│ │ │ │ -   void force_lsd_announce () const;
│ │ │ │ +   void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │     void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ +   void force_lsd_announce () const;
│ │ │ │ +   void force_dht_announce () const;
│ │ │ │     void scrape_tracker (int idx = -1) const;
│ │ │ │     int upload_limit () const;
│ │ │ │     void set_download_limit (int limit) const;
│ │ │ │ -   void set_upload_limit (int limit) const;
│ │ │ │     int download_limit () const;
│ │ │ │ +   void set_upload_limit (int limit) const;
│ │ │ │     void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │     void clear_peers ();
│ │ │ │     void set_max_uploads (int max_uploads) const;
│ │ │ │     int max_uploads () const;
│ │ │ │     void set_max_connections (int max_connections) const;
│ │ │ │     int max_connections () const;
│ │ │ │     void move_storage (std::string const& save_path
│ │ │ │        , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │        ) const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │ -   sha1_hash info_hash () const;
│ │ │ │     info_hash_t info_hashes () const;
│ │ │ │ +   sha1_hash info_hash () const;
│ │ │ │     bool operator< (const torrent_handle& h) const;
│ │ │ │ -   bool operator!= (const torrent_handle& h) const;
│ │ │ │     bool operator== (const torrent_handle& h) const;
│ │ │ │ +   bool operator!= (const torrent_handle& h) const;
│ │ │ │     std::uint32_t id () const;
│ │ │ │     std::shared_ptr<torrent> native_handle () const;
│ │ │ │     client_data_t userdata () const;
│ │ │ │     bool in_session () const;
│ │ │ │  
│ │ │ │     static constexpr add_piece_flags_t overwrite_existing  = 0_bit;
│ │ │ │     static constexpr status_flags_t query_distributed_copies  = 0_bit;
│ │ │ │ @@ -7457,21 +7457,21 @@
│ │ │ │  a peer_info_alert. The alert contain a list of peer_info objects, one
│ │ │ │  for each connected peer.
    
│ │ │ │  
    get_peer_info() is synchronous and takes a reference to a vector
│ │ │ │  that will be cleared and filled with one entry for each peer
│ │ │ │  connected to this torrent, given the handle is valid. Each entry in
│ │ │ │  the vector contains information about that particular peer. See
│ │ │ │  peer_info.
    
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
    
│ │ │ │ -
    post_status() status()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    status() post_status()
    
│ │ │ │  
    │ │ │ │ -torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │  void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │  
    
│ │ │ │  
    status() will return a structure with information about the status
│ │ │ │  of this torrent. If the torrent_handle is invalid, it will throw
│ │ │ │  system_error exception. See torrent_status. The flags
│ │ │ │  argument filters what information is returned in the torrent_status.
│ │ │ │  Some information in there is relatively expensive to calculate, and if
│ │ │ │  you're not interested in it (and see performance issues), you can
│ │ │ │ @@ -7502,16 +7502,16 @@
│ │ │ │  fields in the returned vector.
    
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    clear_piece_deadlines() set_piece_deadline() reset_piece_deadline()
    
│ │ │ │  
    │ │ │ │ -void reset_piece_deadline (piece_index_t index) const;
│ │ │ │  void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +void reset_piece_deadline (piece_index_t index) const;
│ │ │ │  void clear_piece_deadlines () const;
│ │ │ │  
    
│ │ │ │  
    This function sets or resets the deadline associated with a specific
│ │ │ │  piece index (index). libtorrent will attempt to download this
│ │ │ │  entire piece before the deadline expires. This is not necessarily
│ │ │ │  possible, but pieces with a more recent deadline will always be
│ │ │ │  prioritized over pieces with a deadline further ahead in time. The
│ │ │ │ @@ -7523,21 +7523,21 @@
│ │ │ │  
    deadline is the number of milliseconds until this piece should be
│ │ │ │  completed.
    
│ │ │ │  
    reset_piece_deadline removes the deadline from the piece. If it
│ │ │ │  hasn't already been downloaded, it will no longer be considered a
│ │ │ │  priority.
    
│ │ │ │  
    clear_piece_deadlines() removes deadlines on all pieces in
│ │ │ │  the torrent. As if reset_piece_deadline() was called on all pieces.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    file_progress() post_file_progress()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    post_file_progress() file_progress()
    
│ │ │ │  
    │ │ │ │ -std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │  void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │  void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │  
    
│ │ │ │  
    This function fills in the supplied vector, or returns a vector, with
│ │ │ │  the number of bytes downloaded of each file in this torrent. The
│ │ │ │  progress values are ordered the same as the files in the
│ │ │ │  torrent_info.
    
│ │ │ │  
    This operation is not very cheap. Its complexity is O(n + mj).
│ │ │ │ @@ -7567,25 +7567,25 @@
│ │ │ │  
    
│ │ │ │  
    clear_error()
    
│ │ │ │  
    │ │ │ │  void clear_error () const;
│ │ │ │  
    
│ │ │ │  
    If the torrent is in an error state (i.e. torrent_status::error is
│ │ │ │  non-empty), this will clear the error and start the torrent again.
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    post_trackers() replace_trackers() trackers() add_tracker()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_tracker() trackers() post_trackers() replace_trackers()
    
│ │ │ │  
    │ │ │ │ -void post_trackers () const;
│ │ │ │  void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ -void add_tracker (announce_entry const&) const;
│ │ │ │  std::vector<announce_entry> trackers () const;
│ │ │ │ +void add_tracker (announce_entry const&) const;
│ │ │ │ +void post_trackers () const;
│ │ │ │  
    
│ │ │ │  
    trackers() returns the list of trackers for this torrent. The
│ │ │ │  announce entry contains both a string url which specify the
│ │ │ │  announce url for the tracker as well as an int tier, which is
│ │ │ │  specifies the order in which this tracker is tried. If you want
│ │ │ │  libtorrent to use another list of trackers for this torrent, you can
│ │ │ │  use replace_trackers() which takes a list of the same form as the
│ │ │ │ @@ -7604,16 +7604,16 @@
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    add_url_seed() remove_url_seed() url_seeds()
    
│ │ │ │  
    │ │ │ │  void remove_url_seed (std::string const& url) const;
│ │ │ │ -void add_url_seed (std::string const& url) const;
│ │ │ │  std::set<std::string> url_seeds () const;
│ │ │ │ +void add_url_seed (std::string const& url) const;
│ │ │ │  
    
│ │ │ │  
    add_url_seed() adds another url to the torrent's list of url
│ │ │ │  seeds. If the given url already exists in that list, the call has no
│ │ │ │  effect. The torrent will connect to the server and try to download
│ │ │ │  pieces from it, unless it's paused, queued, checking or seeding.
│ │ │ │  remove_url_seed() removes the given url if it exists already.
│ │ │ │  url_seeds() return a set of the url seeds currently in this
│ │ │ │ @@ -7679,16 +7679,16 @@
│ │ │ │  network thread. Also unlike other functions, it never throws
│ │ │ │  the system_error exception.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    resume() pause()
    
│ │ │ │  
    │ │ │ │ -void resume () const;
│ │ │ │  void pause (pause_flags_t flags = {}) const;
│ │ │ │ +void resume () const;
│ │ │ │  
    
│ │ │ │  
    pause(), and resume() will disconnect all peers and reconnect
│ │ │ │  all peers respectively. When a torrent is paused, it will however
│ │ │ │  remember all share ratios to all peers and remember all potential (not
│ │ │ │  connected) peers. Torrents may be paused automatically if there is a
│ │ │ │  file error (e.g. disk full) or something similar. See
│ │ │ │  file_error_alert.
    
│ │ │ │ @@ -7699,24 +7699,24 @@
│ │ │ │  
    
│ │ │ │  
    Note
    
│ │ │ │  
    Torrents that are auto-managed may be automatically resumed again. It
│ │ │ │  does not make sense to pause an auto-managed torrent without making it
│ │ │ │  not auto-managed first. Torrents are auto-managed by default when added
│ │ │ │  to the session. For more information, see queuing.
    
│ │ │ │  
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    flags() unset_flags() set_flags()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_flags() flags() unset_flags()
    
│ │ │ │  
    │ │ │ │ -torrent_flags_t flags () const;
│ │ │ │ -void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │  void unset_flags (torrent_flags_t flags) const;
│ │ │ │  void set_flags (torrent_flags_t flags) const;
│ │ │ │ +torrent_flags_t flags () const;
│ │ │ │ +void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │  
    
│ │ │ │  
    sets and gets the torrent state flags. See torrent_flags_t.
│ │ │ │  The set_flags overload that take a mask will affect all
│ │ │ │  flags part of the mask, and set their values to what the
│ │ │ │  flags argument is set to. This allows clearing and
│ │ │ │  setting flags in a single function call.
│ │ │ │  The set_flags overload that just takes flags, sets all
│ │ │ │ @@ -7853,16 +7853,16 @@
│ │ │ │  report that they don't need to save resume data again, and skipped by
│ │ │ │  the initial loop, and thwart the counter otherwise.
    
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    need_save_resume_data()
    
│ │ │ │  
    │ │ │ │ -bool need_save_resume_data () const;
│ │ │ │  bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ +bool need_save_resume_data () const;
│ │ │ │  
    
│ │ │ │  
    This function returns true if anything that is stored in the resume
│ │ │ │  data has changed since the last time resume data was saved.
│ │ │ │  The overload that takes flags let you ask if specific categories
│ │ │ │  of properties have changed. These flags have the same behavior as in
│ │ │ │  the save_resume_data() call.
    
│ │ │ │  
    This is a blocking call. It will wait for a response from
│ │ │ │ @@ -7872,27 +7872,27 @@
│ │ │ │  
    
│ │ │ │  
    Note
    
│ │ │ │  
    A torrent's resume data is considered saved as soon as the
│ │ │ │  save_resume_data_alert is posted. It is important to make sure this
│ │ │ │  alert is received and handled in order for this function to be
│ │ │ │  meaningful.
    
│ │ │ │  
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    queue_position() queue_position_bottom() queue_position_up() queue_position_top() queue_position_down()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    queue_position_bottom() queue_position_down() queue_position_top() queue_position() queue_position_up()
    
│ │ │ │  
    │ │ │ │ -void queue_position_up () const;
│ │ │ │  void queue_position_bottom () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │  void queue_position_down () const;
│ │ │ │ -queue_position_t queue_position () const;
│ │ │ │  void queue_position_top () const;
│ │ │ │ +queue_position_t queue_position () const;
│ │ │ │  
    
│ │ │ │  
    Every torrent that is added is assigned a queue position exactly one
│ │ │ │  greater than the greatest queue position of all existing torrents.
│ │ │ │  Torrents that are being seeded have -1 as their queue position, since
│ │ │ │  they're no longer in line to be downloaded.
    
│ │ │ │  
    When a torrent is removed or turns into a seed, all torrents with
│ │ │ │  greater queue positions have their positions decreased to fill in the
│ │ │ │ @@ -7916,21 +7916,21 @@
│ │ │ │  of all other torrents remain intact but their numerical queue position
│ │ │ │  shifts to make space for this torrent's new position
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    set_ssl_certificate_buffer() set_ssl_certificate()
    
│ │ │ │  
    │ │ │ │ -void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ -      , std::string const& private_key
│ │ │ │ -      , std::string const& dh_params);
│ │ │ │  void set_ssl_certificate (std::string const& certificate
│ │ │ │        , std::string const& private_key
│ │ │ │        , std::string const& dh_params
│ │ │ │        , std::string const& passphrase = "");
│ │ │ │ +void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ +      , std::string const& private_key
│ │ │ │ +      , std::string const& dh_params);
│ │ │ │  
    
│ │ │ │  
    For SSL torrents, use this to specify a path to a .pem file to use as
│ │ │ │  this client's certificate. The certificate must be signed by the
│ │ │ │  certificate in the .torrent file to be valid.
    
│ │ │ │  
    The set_ssl_certificate_buffer() overload takes the actual certificate,
│ │ │ │  private key and DH params as strings, rather than paths to files.
    
│ │ │ │  
    cert is a path to the (signed) certificate in .pem format
│ │ │ │ @@ -7951,16 +7951,16 @@
│ │ │ │  provide a valid cert. If you don't have a cert you won't be allowed to
│ │ │ │  connect to any peers.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    torrent_file() torrent_file_with_hashes()
    
│ │ │ │  
    │ │ │ │ -std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │  std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ +std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │  
    
│ │ │ │  
    torrent_file() returns a pointer to the torrent_info object
│ │ │ │  associated with this torrent. The torrent_info object may be a copy
│ │ │ │  of the internal object. If the torrent doesn't have metadata, the
│ │ │ │  pointer will not be initialized (i.e. a nullptr). The torrent may be
│ │ │ │  in a state without metadata only if it was started without a .torrent
│ │ │ │  file, e.g. by being added by magnet link.
    
│ │ │ │ @@ -8010,24 +8010,24 @@
│ │ │ │  
    post_piece_availability() will trigger a piece_availability_alert
│ │ │ │  to be posted.
    
│ │ │ │  
    piece_availability() fills the specified std::vector<int>
│ │ │ │  with the availability for each piece in this torrent. libtorrent does
│ │ │ │  not keep track of availability for seeds, so if the torrent is
│ │ │ │  seeding the availability for all pieces is reported as 0.
    
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    get_piece_priorities() piece_priority() prioritize_pieces()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_piece_priorities() prioritize_pieces() piece_priority()
    
│ │ │ │  
    │ │ │ │  void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │  std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │  download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ -void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ -void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │  
    
│ │ │ │  
    These functions are used to set and get the priority of individual
│ │ │ │  pieces. By default all pieces have priority 4. That means that the
│ │ │ │  random rarest first algorithm is effectively active for all pieces.
│ │ │ │  You may however change the priority of individual pieces. There are 8
│ │ │ │  priority levels. 0 means not to download the piece at all. Otherwise,
│ │ │ │  lower priority values means less likely to be picked. Piece priority
│ │ │ │ @@ -8050,23 +8050,23 @@
│ │ │ │  not allowed.
    
│ │ │ │  
    get_piece_priorities returns a vector with one element for each piece
│ │ │ │  in the torrent. Each element is the current priority of that piece.
    
│ │ │ │  
    It's possible to cancel the effect of file priorities by setting the
│ │ │ │  priorities for the affected pieces. Care has to be taken when mixing
│ │ │ │  usage of file- and piece priorities.
    
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    file_priority() get_file_priorities() prioritize_files()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_priority() prioritize_files() get_file_priorities()
    
│ │ │ │  
    │ │ │ │  void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │  std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ -void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │  download_priority_t file_priority (file_index_t index) const;
│ │ │ │ +void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │  
    
│ │ │ │  
    index must be in the range [0, number_of_files).
    
│ │ │ │  
    file_priority() queries or sets the priority of file index.
    
│ │ │ │  
    prioritize_files() takes a vector that has at as many elements as
│ │ │ │  there are files in the torrent. Each entry is the priority of that
│ │ │ │  file. The function sets the priorities of all the pieces in the
│ │ │ │  torrent based on the vector.
    
│ │ │ │ @@ -8089,23 +8089,23 @@
│ │ │ │  file_prio_alert.
    
│ │ │ │  
    When combining file- and piece priorities, the resume file will record
│ │ │ │  both. When loading the resume data, the file priorities will be applied
│ │ │ │  first, then the piece priorities.
    
│ │ │ │  
    Moving data from a file into the part file is currently not
│ │ │ │  supported. If a file has its priority set to 0 after it has already
│ │ │ │  been created, it will not be moved into the partfile.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    force_dht_announce() force_reannounce() force_lsd_announce()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    force_reannounce() force_dht_announce() force_lsd_announce()
    
│ │ │ │  
    │ │ │ │ -void force_dht_announce () const;
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │  void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ +void force_lsd_announce () const;
│ │ │ │ +void force_dht_announce () const;
│ │ │ │  
    
│ │ │ │  
    force_reannounce() will force this torrent to do another tracker
│ │ │ │  request, to receive new peers. The seconds argument specifies how
│ │ │ │  many seconds from now to issue the tracker announces.
    
│ │ │ │  
    If the tracker's min_interval has not passed since the last
│ │ │ │  announce, the forced announce will be scheduled to happen immediately
│ │ │ │  as the min_interval expires. This is to honor trackers minimum
│ │ │ │ @@ -8129,25 +8129,25 @@
│ │ │ │  idx is >= 0, the tracker with the specified index will scraped.
    
│ │ │ │  
    A scrape request queries the tracker for statistics such as total
│ │ │ │  number of incomplete peers, complete peers, number of downloads etc.
    
│ │ │ │  
    This request will specifically update the num_complete and
│ │ │ │  num_incomplete fields in the torrent_status struct once it
│ │ │ │  completes. When it completes, it will generate a scrape_reply_alert.
│ │ │ │  If it fails, it will generate a scrape_failed_alert.
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    upload_limit() set_download_limit() download_limit() set_upload_limit()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    download_limit() set_download_limit() set_upload_limit() upload_limit()
    
│ │ │ │  
    │ │ │ │  int upload_limit () const;
│ │ │ │  void set_download_limit (int limit) const;
│ │ │ │ -void set_upload_limit (int limit) const;
│ │ │ │  int download_limit () const;
│ │ │ │ +void set_upload_limit (int limit) const;
│ │ │ │  
    
│ │ │ │  
    set_upload_limit will limit the upload bandwidth used by this
│ │ │ │  particular torrent to the limit you set. It is given as the number of
│ │ │ │  bytes per second the torrent is allowed to upload.
│ │ │ │  set_download_limit works the same way but for download bandwidth
│ │ │ │  instead of upload bandwidth. Note that setting a higher limit on a
│ │ │ │  torrent then the global limit
│ │ │ │ @@ -8193,18 +8193,18 @@
│ │ │ │  
│ │ │ │  
    set_max_uploads() sets the maximum number of peers that's unchoked
│ │ │ │  at the same time on this torrent. If you set this to -1, there will be
│ │ │ │  no limit. This defaults to infinite. The primary setting controlling
│ │ │ │  this is the global unchoke slots limit, set by unchoke_slots_limit in
│ │ │ │  settings_pack.
    
│ │ │ │  
    max_uploads() returns the current settings.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    max_connections() set_max_connections()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_max_connections() max_connections()
    
│ │ │ │  
    │ │ │ │  void set_max_connections (int max_connections) const;
│ │ │ │  int max_connections () const;
│ │ │ │  
    
│ │ │ │  
    set_max_connections() sets the maximum number of connection this
│ │ │ │  torrent will open. If all connections are used up, incoming
│ │ │ │  connections may be refused or poor connections may be closed. This
│ │ │ │ @@ -8270,37 +8270,37 @@
│ │ │ │  
    rename_file()
    
│ │ │ │  
    │ │ │ │  void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │  
    
│ │ │ │  
    Renames the file with the given index asynchronously. The rename
│ │ │ │  operation is complete when either a file_renamed_alert or
│ │ │ │  file_rename_failed_alert is posted.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    info_hashes() info_hash()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    info_hash() info_hashes()
    
│ │ │ │  
    │ │ │ │ -sha1_hash info_hash () const;
│ │ │ │  info_hash_t info_hashes () const;
│ │ │ │ +sha1_hash info_hash () const;
│ │ │ │  
    
│ │ │ │  
    returns the info-hash(es) of the torrent. If this handle is to a
│ │ │ │  torrent that hasn't loaded yet (for instance by being added) by a
│ │ │ │  URL, the returned value is undefined.
│ │ │ │  The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │  truncated hash for v2 torrents. For the full v2 info-hash, use
│ │ │ │  info_hashes() instead.
    
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ +
│ │ │ │ +[report issue]
│ │ │ │  
    
│ │ │ │ -
    operator==() operator!=() operator<()
    
│ │ │ │ +
    operator==() operator<() operator!=()
    
│ │ │ │  
    │ │ │ │  bool operator< (const torrent_handle& h) const;
│ │ │ │ -bool operator!= (const torrent_handle& h) const;
│ │ │ │  bool operator== (const torrent_handle& h) const;
│ │ │ │ +bool operator!= (const torrent_handle& h) const;
│ │ │ │  
    
│ │ │ │  
    comparison operators. The order of the torrents is unspecified
│ │ │ │  but stable.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    id()
    
│ │ │ │  
    │ │ │ │ @@ -8888,17 +8888,17 @@
│ │ │ │  internal libtorrent torrent object to tie the storage object allocated
│ │ │ │  for a torrent to the lifetime of the internal torrent object. When a
│ │ │ │  torrent is removed from the session, this holder is destructed and will
│ │ │ │  inform the disk object.
    
│ │ │ │  
    │ │ │ │  struct storage_holder
│ │ │ │  {
│ │ │ │ -   ~storage_holder ();
│ │ │ │     storage_holder () = default;
│ │ │ │     storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ +   ~storage_holder ();
│ │ │ │     explicit operator bool () const;
│ │ │ │     operator storage_index_t () const;
│ │ │ │     void reset ();
│ │ │ │     storage_holder& operator= (storage_holder const&) = delete;
│ │ │ │     storage_holder (storage_holder const&) = delete;
│ │ │ │     storage_holder (storage_holder&& rhs) noexcept;
│ │ │ │     storage_holder& operator= (storage_holder&& rhs) noexcept;
│ │ │ │ @@ -9030,20 +9030,20 @@
│ │ │ │  
    Declared in "libtorrent/settings_pack.hpp"
    
│ │ │ │  
    the common interface to settings_pack and the internal representation of
│ │ │ │  settings.
    
│ │ │ │  
    │ │ │ │  struct settings_interface
│ │ │ │  {
│ │ │ │     virtual bool has_val (int name) const = 0;
│ │ │ │ -   virtual void set_str (int name, std::string val) = 0;
│ │ │ │     virtual void set_int (int name, int val) = 0;
│ │ │ │ +   virtual void set_str (int name, std::string val) = 0;
│ │ │ │     virtual void set_bool (int name, bool val) = 0;
│ │ │ │     virtual bool get_bool (int name) const = 0;
│ │ │ │ -   virtual std::string const& get_str (int name) const = 0;
│ │ │ │     virtual int get_int (int name) const = 0;
│ │ │ │ +   virtual std::string const& get_str (int name) const = 0;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    file_open_mode_t
    
│ │ │ │  
    Declared in "libtorrent/disk_interface.hpp"
    
│ │ │ │  
    
│ │ │ │ @@ -10145,17 +10145,17 @@
│ │ │ │     std::string message () const override;
│ │ │ │     char const* storage_path () const;
│ │ │ │     char const* old_path () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::storage;
│ │ │ │  };
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    storage_path() old_path()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    old_path() storage_path()
    
│ │ │ │  
    │ │ │ │  char const* storage_path () const;
│ │ │ │  char const* old_path () const;
│ │ │ │  
    
│ │ │ │  
    the path the torrent was moved to and from, respectively.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -11796,27 +11796,27 @@
│ │ │ │  
    posted in response to a call to session::dht_live_nodes(). It contains the
│ │ │ │  live nodes from the DHT routing table of one of the DHT nodes running
│ │ │ │  locally.
    
│ │ │ │  
    │ │ │ │  struct dht_live_nodes_alert final : alert
│ │ │ │  {
│ │ │ │     std::string message () const override;
│ │ │ │ -   int num_nodes () const;
│ │ │ │     std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │ +   int num_nodes () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::dht;
│ │ │ │     sha1_hash node_id;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    num_nodes() nodes()
    
│ │ │ │  
    │ │ │ │ -int num_nodes () const;
│ │ │ │  std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │ +int num_nodes () const;
│ │ │ │  
    
│ │ │ │  
    the number of nodes in the routing table and the actual nodes.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    node_id
    
│ │ │ │  
    the local DHT node's node-ID this routing table belongs to
    
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -11857,17 +11857,17 @@
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::dht_operation;
│ │ │ │     sha1_hash node_id;
│ │ │ │     aux::noexcept_movable<udp::endpoint> endpoint;
│ │ │ │     time_duration const interval;
│ │ │ │     int const num_infohashes;
│ │ │ │  };
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    samples() num_samples()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    num_samples() samples()
    
│ │ │ │  
    │ │ │ │  std::vector<sha1_hash> samples () const;
│ │ │ │  int num_samples () const;
│ │ │ │  
    
│ │ │ │  
    returns the number of info-hashes returned by the node, as well as the
│ │ │ │  actual info-hashes. num_samples() is more efficient than
│ │ │ │  samples().size().
    
│ │ │ │ @@ -12151,16 +12151,16 @@
│ │ │ │  
    list of trackers and their status for the torrent
    
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    alert_cast()
    
│ │ │ │  
    Declared in "libtorrent/alert.hpp"
    
│ │ │ │  
    │ │ │ │ -template <typename T> T const* alert_cast (alert const* a);
│ │ │ │  template <typename T> T* alert_cast (alert* a);
│ │ │ │ +template <typename T> T const* alert_cast (alert const* a);
│ │ │ │  
    
│ │ │ │  
    When you get an alert, you can use alert_cast<> to attempt to cast the
│ │ │ │  pointer to a specific alert type, in order to query it for more
│ │ │ │  information.
    
│ │ │ │  
    
│ │ │ │  
    Note
    
│ │ │ │  
    alert_cast<> can only cast to an exact alert type, not a base class
    
│ │ │ │ @@ -12537,28 +12537,28 @@
│ │ │ │  
    
│ │ │ │  
    counters
    
│ │ │ │  
    Declared in "libtorrent/performance_counters.hpp"
    
│ │ │ │  
    │ │ │ │  struct counters
│ │ │ │  {
│ │ │ │     counters () ;
│ │ │ │ -   counters& operator= (counters const&) & ;
│ │ │ │     counters (counters const&) ;
│ │ │ │ -   std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ +   counters& operator= (counters const&) & ;
│ │ │ │     std::int64_t operator[] (int i) const ;
│ │ │ │ -   void set_value (int c, std::int64_t value) ;
│ │ │ │ +   std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │     void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │ +   void set_value (int c, std::int64_t value) ;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    operator[]() inc_stats_counter()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    inc_stats_counter() operator[]()
    
│ │ │ │  
    │ │ │ │ -std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │  std::int64_t operator[] (int i) const ;
│ │ │ │ +std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │  
    
│ │ │ │  
    returns the new value
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    stats_metric
    
│ │ │ │  
    Declared in "libtorrent/session_stats.hpp"
    
│ │ │ │ @@ -12642,18 +12642,18 @@
│ │ │ │  the IPv4 range, and the equivalent range covering all addresses for the
│ │ │ │  IPv6 range).
    
│ │ │ │  
    A default constructed ip_filter does not filter any address.
    
│ │ │ │  
    │ │ │ │  struct ip_filter
│ │ │ │  {
│ │ │ │     ip_filter ();
│ │ │ │ -   ip_filter& operator= (ip_filter&&);
│ │ │ │ +   ~ip_filter ();
│ │ │ │     ip_filter (ip_filter&&);
│ │ │ │     ip_filter (ip_filter const&);
│ │ │ │ -   ~ip_filter ();
│ │ │ │ +   ip_filter& operator= (ip_filter&&);
│ │ │ │     ip_filter& operator= (ip_filter const&);
│ │ │ │     bool empty () const;
│ │ │ │     void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (address const& addr) const;
│ │ │ │     filter_tuple_t export_filter () const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │ @@ -12739,19 +12739,19 @@
│ │ │ │  is primarily used to indicate whether a range of ports should
│ │ │ │  be connected to or not. The default is to have the full port
│ │ │ │  range (0-65535) set to flag 0.
    
│ │ │ │  
    │ │ │ │  class port_filter
│ │ │ │  {
│ │ │ │     ~port_filter ();
│ │ │ │ -   port_filter& operator= (port_filter&&);
│ │ │ │ -   port_filter ();
│ │ │ │     port_filter (port_filter&&);
│ │ │ │ -   port_filter& operator= (port_filter const&);
│ │ │ │ +   port_filter ();
│ │ │ │     port_filter (port_filter const&);
│ │ │ │ +   port_filter& operator= (port_filter const&);
│ │ │ │ +   port_filter& operator= (port_filter&&);
│ │ │ │     void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (std::uint16_t port) const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │     {
│ │ │ │        blocked,
│ │ │ │     };
│ │ │ │ @@ -12819,46 +12819,46 @@
│ │ │ │  
    The entry class represents one node in a bencoded hierarchy. It works as a
│ │ │ │  variant type, it can be either a list, a dictionary (std::map), an integer
│ │ │ │  or a string.
    
│ │ │ │  
    │ │ │ │  class entry
│ │ │ │  {
│ │ │ │     data_type type () const;
│ │ │ │ -   entry (integer_type);
│ │ │ │ +   entry (dictionary_type);
│ │ │ │     entry (preformatted_type);
│ │ │ │     entry (list_type);
│ │ │ │     entry (span<char const>);
│ │ │ │ -   entry (dictionary_type);
│ │ │ │ +   entry (integer_type);
│ │ │ │     entry (U v);
│ │ │ │     entry (data_type t);
│ │ │ │     entry (bdecode_node const& n);
│ │ │ │     entry& operator= (dictionary_type) &;
│ │ │ │ -   entry& operator= (bdecode_node const&) &;
│ │ │ │     entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (integer_type) &;
│ │ │ │ +   entry& operator= (bdecode_node const&) &;
│ │ │ │ +   entry& operator= (entry&&) & noexcept;
│ │ │ │     entry& operator= (list_type) &;
│ │ │ │ -   entry& operator= (entry const&) &;
│ │ │ │     entry& operator= (span<char const>) &;
│ │ │ │ -   entry& operator= (entry&&) & noexcept;
│ │ │ │ -   entry& operator= (integer_type) &;
│ │ │ │ +   entry& operator= (entry const&) &;
│ │ │ │     entry& operator= (U v) &;
│ │ │ │     integer_type& integer ();
│ │ │ │ +   preformatted_type const& preformatted () const;
│ │ │ │ +   integer_type const& integer () const;
│ │ │ │     list_type& list ();
│ │ │ │ +   string_type& string ();
│ │ │ │ +   preformatted_type& preformatted ();
│ │ │ │     list_type const& list () const;
│ │ │ │     string_type const& string () const;
│ │ │ │ -   dictionary_type const& dict () const;
│ │ │ │ -   preformatted_type const& preformatted () const;
│ │ │ │     dictionary_type& dict ();
│ │ │ │ -   preformatted_type& preformatted ();
│ │ │ │ -   integer_type const& integer () const;
│ │ │ │ -   string_type& string ();
│ │ │ │ +   dictionary_type const& dict () const;
│ │ │ │     void swap (entry& e);
│ │ │ │     entry& operator[] (string_view key);
│ │ │ │     entry const& operator[] (string_view key) const;
│ │ │ │ -   entry* find_key (string_view key);
│ │ │ │     entry const* find_key (string_view key) const;
│ │ │ │ +   entry* find_key (string_view key);
│ │ │ │     std::string to_string (bool single_line = false) const;
│ │ │ │  
│ │ │ │     enum data_type
│ │ │ │     {
│ │ │ │        int_t,
│ │ │ │        string_t,
│ │ │ │        list_t,
│ │ │ │ @@ -12874,19 +12874,19 @@
│ │ │ │  data_type type () const;
│ │ │ │  
    
│ │ │ │  
    returns the concrete type of the entry
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    entry()
    
│ │ │ │  
    │ │ │ │ -entry (integer_type);
│ │ │ │ +entry (dictionary_type);
│ │ │ │  entry (preformatted_type);
│ │ │ │  entry (list_type);
│ │ │ │  entry (span<char const>);
│ │ │ │ -entry (dictionary_type);
│ │ │ │ +entry (integer_type);
│ │ │ │  
    
│ │ │ │  
    constructors directly from a specific type.
│ │ │ │  The content of the argument is copied into the
│ │ │ │  newly constructed entry
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    entry()
    
│ │ │ │ @@ -12903,42 +12903,42 @@
│ │ │ │  
│ │ │ │  
    construct from bdecode_node parsed form (see bdecode())
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    operator=()
    
│ │ │ │  
    │ │ │ │  entry& operator= (dictionary_type) &;
│ │ │ │ -entry& operator= (bdecode_node const&) &;
│ │ │ │  entry& operator= (preformatted_type) &;
│ │ │ │ +entry& operator= (integer_type) &;
│ │ │ │ +entry& operator= (bdecode_node const&) &;
│ │ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ │  entry& operator= (list_type) &;
│ │ │ │ -entry& operator= (entry const&) &;
│ │ │ │  entry& operator= (span<char const>) &;
│ │ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ │ -entry& operator= (integer_type) &;
│ │ │ │ +entry& operator= (entry const&) &;
│ │ │ │  
    
│ │ │ │  
    copies the structure of the right hand side into this
│ │ │ │  entry.
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    integer() dict() list() preformatted() string()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    string() integer() list() dict() preformatted()
    
│ │ │ │  
    │ │ │ │  integer_type& integer ();
│ │ │ │ +preformatted_type const& preformatted () const;
│ │ │ │ +integer_type const& integer () const;
│ │ │ │  list_type& list ();
│ │ │ │ +string_type& string ();
│ │ │ │ +preformatted_type& preformatted ();
│ │ │ │  list_type const& list () const;
│ │ │ │  string_type const& string () const;
│ │ │ │ -dictionary_type const& dict () const;
│ │ │ │ -preformatted_type const& preformatted () const;
│ │ │ │  dictionary_type& dict ();
│ │ │ │ -preformatted_type& preformatted ();
│ │ │ │ -integer_type const& integer () const;
│ │ │ │ -string_type& string ();
│ │ │ │ +dictionary_type const& dict () const;
│ │ │ │  
    
│ │ │ │  
    The integer(), string(), list() and dict() functions
│ │ │ │  are accessors that return the respective type. If the entry object
│ │ │ │  isn't of the type you request, the accessor will throw
│ │ │ │  system_error. You can ask an entry for its type through the
│ │ │ │  type() function.
    
│ │ │ │  
    If you want to create an entry you give it the type you want it to
│ │ │ │ @@ -12998,16 +12998,16 @@
│ │ │ │  
    The const version of operator[] will only return a reference to an
│ │ │ │  existing element at the given key. If the key is not found, it will
│ │ │ │  throw system_error.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    find_key()
    
│ │ │ │  
    │ │ │ │ -entry* find_key (string_view key);
│ │ │ │  entry const* find_key (string_view key) const;
│ │ │ │ +entry* find_key (string_view key);
│ │ │ │  
    
│ │ │ │  
    These functions requires the entry to be a dictionary, if it isn't
│ │ │ │  they will throw system_error.
    
│ │ │ │  
    They will look for an element at the given key in the dictionary, if
│ │ │ │  the element cannot be found, they will return nullptr. If an element
│ │ │ │  with the given key is found, the return a pointer to it.
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -13148,32 +13148,32 @@
│ │ │ │     std::vector<char> generate_buf () const;
│ │ │ │     file_storage const& files () const;
│ │ │ │     void set_comment (char const* str);
│ │ │ │     void set_creator (char const* str);
│ │ │ │     void set_creation_date (std::time_t timestamp);
│ │ │ │     void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ │     void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ │ -   void add_url_seed (string_view url);
│ │ │ │     void add_http_seed (string_view url);
│ │ │ │ +   void add_url_seed (string_view url);
│ │ │ │     void add_node (std::pair<std::string, int> node);
│ │ │ │     void add_tracker (string_view url, int tier = 0);
│ │ │ │     void set_root_cert (string_view cert);
│ │ │ │     void set_priv (bool p);
│ │ │ │     bool priv () const;
│ │ │ │     bool is_v1_only () const;
│ │ │ │     bool is_v2_only () const;
│ │ │ │     int num_pieces () const;
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │     index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │     file_index_t end_file () const;
│ │ │ │     index_range<file_index_t> file_range () const noexcept;
│ │ │ │     index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int piece_length () const;
│ │ │ │     int piece_size (piece_index_t i) const;
│ │ │ │ +   int piece_length () const;
│ │ │ │     void add_similar_torrent (sha1_hash ih);
│ │ │ │     void add_collection (string_view c);
│ │ │ │  
│ │ │ │     static constexpr create_flags_t modification_time  = 2_bit;
│ │ │ │     static constexpr create_flags_t symlinks  = 3_bit;
│ │ │ │     static constexpr create_flags_t v2_only  = 5_bit;
│ │ │ │     static constexpr create_flags_t v1_only  = 6_bit;
│ │ │ │ @@ -13207,18 +13207,18 @@
│ │ │ │  have any affect. Instead of using this overload, consider using
│ │ │ │  write_torrent_file() instead.
    
│ │ │ │  
    
│ │ │ │  
    Warning
    
│ │ │ │  
    The file_storage and torrent_info objects must stay alive for the
│ │ │ │  entire duration of the create_torrent object.
    
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    generate() generate_buf()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    generate_buf() generate()
    
│ │ │ │  
    │ │ │ │  entry generate () const;
│ │ │ │  std::vector<char> generate_buf () const;
│ │ │ │  
    
│ │ │ │  
    This function will generate the .torrent file as a bencode tree, or a
│ │ │ │  bencoded into a buffer.
│ │ │ │  In order to encode the entry into a flat file, use the bencode() function.
    
│ │ │ │ @@ -13309,16 +13309,16 @@
│ │ │ │  This function will throw std::system_error if it is called on an
│ │ │ │  object constructed with the v1_only flag.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    add_url_seed() add_http_seed()
    
│ │ │ │  
    │ │ │ │ -void add_url_seed (string_view url);
│ │ │ │  void add_http_seed (string_view url);
│ │ │ │ +void add_url_seed (string_view url);
│ │ │ │  
    
│ │ │ │  
    This adds a url seed to the torrent. You can have any number of url seeds. For a
│ │ │ │  single file torrent, this should be an HTTP url, pointing to a file with identical
│ │ │ │  content as the file of the torrent. For a multi-file torrent, it should point to
│ │ │ │  a directory containing a directory with the same name as this torrent, and all the
│ │ │ │  files of the torrent in it.
    
│ │ │ │  
    The second function, add_http_seed() adds an HTTP seed instead.
    
│ │ │ │ @@ -13352,18 +13352,18 @@
│ │ │ │  
│ │ │ │  
    This function sets an X.509 certificate in PEM format to the torrent. This makes the
│ │ │ │  torrent an SSL torrent. An SSL torrent requires that each peer has a valid certificate
│ │ │ │  signed by this root certificate. For SSL torrents, all peers are connecting over SSL
│ │ │ │  connections. For more information, see the section on ssl torrents.
    
│ │ │ │  
    The string is not the path to the cert, it's the actual content of the
│ │ │ │  certificate.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    priv() set_priv()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_priv() priv()
    
│ │ │ │  
    │ │ │ │  void set_priv (bool p);
│ │ │ │  bool priv () const;
│ │ │ │  
    
│ │ │ │  
    Sets and queries the private flag of the torrent.
│ │ │ │  Torrents with the private flag set ask the client to not use any other
│ │ │ │  sources than the tracker for peers, and to not use DHT to advertise itself publicly,
│ │ │ │ @@ -13401,21 +13401,21 @@
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    total_size()
    
│ │ │ │  
    │ │ │ │  std::int64_t total_size () const;
│ │ │ │  
    
│ │ │ │  
    the total number of bytes of all files and pad files
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    piece_length() piece_size()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    piece_size() piece_length()
    
│ │ │ │  
    │ │ │ │ -int piece_length () const;
│ │ │ │  int piece_size (piece_index_t i) const;
│ │ │ │ +int piece_length () const;
│ │ │ │  
    
│ │ │ │  
    piece_length() returns the piece size of all pieces but the
│ │ │ │  last one. piece_size() returns the size of the specified piece.
│ │ │ │  these functions are just forwarding to the associated file_storage.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -13514,29 +13514,29 @@
│ │ │ │  
    The flags argument should be the same as the flags passed to the create_torrent
│ │ │ │  constructor.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    set_piece_hashes()
    
│ │ │ │  
    Declared in "libtorrent/create_torrent.hpp"
    
│ │ │ │  
    │ │ │ │ -void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │     , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │     , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │  inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │  inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f);
│ │ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ +   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │  
    
│ │ │ │  
    This function will assume that the files added to the torrent file exists at path
│ │ │ │  p, read those files and hash the content and set the hashes in the create_torrent
│ │ │ │  object. The optional function f is called in between every hash that is set. f
│ │ │ │  must have the following signature:
    
│ │ │ │  
    │ │ │ │  void Fun(piece_index_t);
│ │ │ │ @@ -13550,49 +13550,49 @@
│ │ │ │  
    bitfield
    
│ │ │ │  
    Declared in "libtorrent/bitfield.hpp"
    
│ │ │ │  
    The bitfield type stores any number of bits as a bitfield
│ │ │ │  in a heap allocated array.
    
│ │ │ │  
    │ │ │ │  struct bitfield
│ │ │ │  {
│ │ │ │ +   bitfield () noexcept = default;
│ │ │ │ +   bitfield (int bits, bool val);
│ │ │ │     bitfield (char const* b, int bits);
│ │ │ │ -   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │     explicit bitfield (int bits);
│ │ │ │     bitfield (bitfield const& rhs);
│ │ │ │ -   bitfield (int bits, bool val);
│ │ │ │ -   bitfield () noexcept = default;
│ │ │ │ +   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │     void assign (char const* b, int const bits);
│ │ │ │ -   bool operator[] (int index) const noexcept;
│ │ │ │     bool get_bit (int index) const noexcept;
│ │ │ │ -   void clear_bit (int index) noexcept;
│ │ │ │ +   bool operator[] (int index) const noexcept;
│ │ │ │     void set_bit (int index) noexcept;
│ │ │ │ +   void clear_bit (int index) noexcept;
│ │ │ │     bool all_set () const noexcept;
│ │ │ │     bool none_set () const noexcept;
│ │ │ │     int size () const noexcept;
│ │ │ │     int num_words () const noexcept;
│ │ │ │     int num_bytes () const noexcept;
│ │ │ │     bool empty () const noexcept;
│ │ │ │ -   char* data () noexcept;
│ │ │ │     char const* data () const noexcept;
│ │ │ │ +   char* data () noexcept;
│ │ │ │     void swap (bitfield& rhs) noexcept;
│ │ │ │     int count () const noexcept;
│ │ │ │     int find_first_set () const noexcept;
│ │ │ │     int find_last_clear () const noexcept;
│ │ │ │     bool operator== (lt::bitfield const& rhs) const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    bitfield()
    
│ │ │ │  
    │ │ │ │ +bitfield () noexcept = default;
│ │ │ │ +bitfield (int bits, bool val);
│ │ │ │  bitfield (char const* b, int bits);
│ │ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │  explicit bitfield (int bits);
│ │ │ │  bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (int bits, bool val);
│ │ │ │ -bitfield () noexcept = default;
│ │ │ │ +bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │  
    
│ │ │ │  
    constructs a new bitfield. The default constructor creates an empty
│ │ │ │  bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │  val is the value to initialize the bits to. If not specified
│ │ │ │  all bits are initialized to 0.
    
│ │ │ │  
    The constructor taking a pointer b and bits copies a bitfield
│ │ │ │  from the specified buffer, and bits number of bits (rounded up to
│ │ │ │ @@ -13606,25 +13606,25 @@
│ │ │ │  
    copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │  the nearest byte boundary.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    operator[]() get_bit()
    
│ │ │ │  
    │ │ │ │ -bool operator[] (int index) const noexcept;
│ │ │ │  bool get_bit (int index) const noexcept;
│ │ │ │ +bool operator[] (int index) const noexcept;
│ │ │ │  
    
│ │ │ │  
    query bit at index. Returns true if bit is 1, otherwise false.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_bit() clear_bit()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    clear_bit() set_bit()
    
│ │ │ │  
    │ │ │ │ -void clear_bit (int index) noexcept;
│ │ │ │  void set_bit (int index) noexcept;
│ │ │ │ +void clear_bit (int index) noexcept;
│ │ │ │  
    
│ │ │ │  
    set bit at index to 0 (clear_bit) or 1 (set_bit).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    all_set()
    
│ │ │ │  
    │ │ │ │  bool all_set () const noexcept;
│ │ │ │ @@ -13667,16 +13667,16 @@
│ │ │ │  bool empty () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns true if the bitfield has zero size.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    data()
    
│ │ │ │  
    │ │ │ │ -char* data () noexcept;
│ │ │ │  char const* data () const noexcept;
│ │ │ │ +char* data () noexcept;
│ │ │ │  
    
│ │ │ │  
    returns a pointer to the internal buffer of the bitfield, or
│ │ │ │  nullptr if it's empty.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    swap()
    
│ │ │ │  
    │ │ │ │ @@ -13722,32 +13722,32 @@
│ │ │ │  
    The built-in software version of sha1-algorithm was implemented
│ │ │ │  by Steve Reid and released as public domain.
│ │ │ │  For more info, see src/sha1.cpp.
    
│ │ │ │  
    │ │ │ │  class hasher
│ │ │ │  {
│ │ │ │     hasher ();
│ │ │ │ -   explicit hasher (span<char const> data);
│ │ │ │ +   hasher (hasher const&);
│ │ │ │     hasher (char const* data, int len);
│ │ │ │ +   explicit hasher (span<char const> data);
│ │ │ │     hasher& operator= (hasher const&) &;
│ │ │ │ -   hasher (hasher const&);
│ │ │ │     hasher& update (char const* data, int len);
│ │ │ │     hasher& update (span<char const> data);
│ │ │ │     sha1_hash final ();
│ │ │ │     void reset ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    operator=() hasher()
    
│ │ │ │  
    │ │ │ │ -explicit hasher (span<char const> data);
│ │ │ │ +hasher (hasher const&);
│ │ │ │  hasher (char const* data, int len);
│ │ │ │ +explicit hasher (span<char const> data);
│ │ │ │  hasher& operator= (hasher const&) &;
│ │ │ │ -hasher (hasher const&);
│ │ │ │  
    
│ │ │ │  
    this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    update()
    
│ │ │ │  
    │ │ │ │ @@ -13776,42 +13776,42 @@
│ │ │ │  
    
│ │ │ │  
    hasher256
    
│ │ │ │  
    Declared in "libtorrent/hasher.hpp"
    
│ │ │ │  
    │ │ │ │  class hasher256
│ │ │ │  {
│ │ │ │     hasher256 ();
│ │ │ │ -   hasher256& operator= (hasher256 const&) &;
│ │ │ │     explicit hasher256 (span<char const> data);
│ │ │ │ -   hasher256 (hasher256 const&);
│ │ │ │     hasher256 (char const* data, int len);
│ │ │ │ -   hasher256& update (span<char const> data);
│ │ │ │ +   hasher256 (hasher256 const&);
│ │ │ │ +   hasher256& operator= (hasher256 const&) &;
│ │ │ │     hasher256& update (char const* data, int len);
│ │ │ │ +   hasher256& update (span<char const> data);
│ │ │ │     sha256_hash final ();
│ │ │ │     void reset ();
│ │ │ │     ~hasher256 ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    hasher256() operator=()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    operator=() hasher256()
    
│ │ │ │  
    │ │ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ │  explicit hasher256 (span<char const> data);
│ │ │ │ -hasher256 (hasher256 const&);
│ │ │ │  hasher256 (char const* data, int len);
│ │ │ │ +hasher256 (hasher256 const&);
│ │ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ │  
    
│ │ │ │  
    this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    update()
    
│ │ │ │  
    │ │ │ │ -hasher256& update (span<char const> data);
│ │ │ │  hasher256& update (char const* data, int len);
│ │ │ │ +hasher256& update (span<char const> data);
│ │ │ │  
    
│ │ │ │  
    append the following bytes to what is being hashed
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    final()
    
│ │ │ │  
    │ │ │ │  sha256_hash final ();
│ │ │ │ @@ -14497,19 +14497,19 @@
│ │ │ │  
    announce_entry
    
│ │ │ │  
    Declared in "libtorrent/announce_entry.hpp"
    
│ │ │ │  
    this class holds information about one bittorrent tracker, as it
│ │ │ │  relates to a specific torrent.
    
│ │ │ │  
    │ │ │ │  struct announce_entry
│ │ │ │  {
│ │ │ │ -   ~announce_entry ();
│ │ │ │ -   explicit announce_entry (string_view u);
│ │ │ │     announce_entry (announce_entry const&);
│ │ │ │     announce_entry& operator= (announce_entry const&) &;
│ │ │ │     announce_entry ();
│ │ │ │ +   explicit announce_entry (string_view u);
│ │ │ │ +   ~announce_entry ();
│ │ │ │  
│ │ │ │     enum tracker_source
│ │ │ │     {
│ │ │ │        source_torrent,
│ │ │ │        source_client,
│ │ │ │        source_magnet_link,
│ │ │ │        source_tex,
│ │ │ │ @@ -14525,19 +14525,19 @@
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    announce_entry() operator=() ~announce_entry()
    
│ │ │ │  
    │ │ │ │ -~announce_entry ();
│ │ │ │ -explicit announce_entry (string_view u);
│ │ │ │  announce_entry (announce_entry const&);
│ │ │ │  announce_entry& operator= (announce_entry const&) &;
│ │ │ │  announce_entry ();
│ │ │ │ +explicit announce_entry (string_view u);
│ │ │ │ +~announce_entry ();
│ │ │ │  
    
│ │ │ │  
    constructs a tracker announce entry with u as the URL.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    enum tracker_source
    
│ │ │ │  
    Declared in "libtorrent/announce_entry.hpp"
    
│ │ │ │  
    
│ │ │ │ @@ -19148,24 +19148,24 @@
│ │ │ │  
│ │ │ │  
    │ │ │ │  struct settings_pack final : settings_interface
│ │ │ │  {
│ │ │ │     friend  void apply_pack_impl (settings_pack const*
│ │ │ │        , aux::session_settings_single_thread&
│ │ │ │        , std::vector<void(aux::session_impl::*)()>*);
│ │ │ │ -   void set_int (int name, int val) override;
│ │ │ │ -   void set_str (int name, std::string val) override;
│ │ │ │ -   void set_bool (int name, bool val) override;
│ │ │ │     void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +   void set_bool (int name, bool val) override;
│ │ │ │ +   void set_str (int name, std::string val) override;
│ │ │ │ +   void set_int (int name, int val) override;
│ │ │ │     bool has_val (int name) const override;
│ │ │ │     void clear ();
│ │ │ │     void clear (int name);
│ │ │ │ -   std::string const& get_str (int name) const override;
│ │ │ │     bool get_bool (int name) const override;
│ │ │ │     int get_int (int name) const override;
│ │ │ │ +   std::string const& get_str (int name) const override;
│ │ │ │     void for_each (Fun&& f) const;
│ │ │ │  
│ │ │ │     enum type_bases
│ │ │ │     {
│ │ │ │        string_type_base,
│ │ │ │        int_type_base,
│ │ │ │        bool_type_base,
│ │ │ │ @@ -19235,23 +19235,23 @@
│ │ │ │        socks5,
│ │ │ │        socks5_pw,
│ │ │ │        http,
│ │ │ │        http_pw,
│ │ │ │     };
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    set_bool() set_str() set_int()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    set_str() set_bool() set_int()
    
│ │ │ │  
    │ │ │ │ -void set_int (int name, int val) override;
│ │ │ │ -void set_str (int name, std::string val) override;
│ │ │ │ -void set_bool (int name, bool val) override;
│ │ │ │  void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +void set_bool (int name, bool val) override;
│ │ │ │ +void set_str (int name, std::string val) override;
│ │ │ │ +void set_int (int name, int val) override;
│ │ │ │  
    
│ │ │ │  
    set a configuration option in the settings_pack. name is one of
│ │ │ │  the enum values from string_types, int_types or bool_types. They must
│ │ │ │  match the respective type of the set_* function.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    has_val()
    
│ │ │ │ @@ -19271,23 +19271,23 @@
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    clear()
    
│ │ │ │  
    │ │ │ │  void clear (int name);
│ │ │ │  
    
│ │ │ │  
    clear a specific setting from the pack
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    get_bool() get_int() get_str()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_str() get_int() get_bool()
    
│ │ │ │  
    │ │ │ │ -std::string const& get_str (int name) const override;
│ │ │ │  bool get_bool (int name) const override;
│ │ │ │  int get_int (int name) const override;
│ │ │ │ +std::string const& get_str (int name) const override;
│ │ │ │  
    
│ │ │ │  
    queries the current configuration option from the settings_pack.
│ │ │ │  name is one of the enumeration values from string_types, int_types
│ │ │ │  or bool_types. The enum value must match the type of the get_*
│ │ │ │  function. If the specified setting field has not been set, the default
│ │ │ │  value is returned.
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -19739,16 +19739,16 @@
│ │ │ │  upload rates by allowing large send buffers.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    setting_by_name() name_for_setting()
    
│ │ │ │  
    Declared in "libtorrent/settings_pack.hpp"
    
│ │ │ │  
    │ │ │ │ -int setting_by_name (string_view name);
│ │ │ │  char const* name_for_setting (int s);
│ │ │ │ +int setting_by_name (string_view name);
│ │ │ │  
    
│ │ │ │  
    converts a setting integer (from the enums string_types, int_types or
│ │ │ │  bool_types) to a string, and vice versa.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    default_settings()
    
│ │ │ │  
    Declared in "libtorrent/settings_pack.hpp"
    
│ │ │ │ @@ -19764,45 +19764,45 @@
│ │ │ │  to be able to copy it as a reference for instance). For that, use the
│ │ │ │  non_owning() member function.
    
│ │ │ │  
    There are 5 different types of nodes, see type_t.
    
│ │ │ │  
    │ │ │ │  struct bdecode_node
│ │ │ │  {
│ │ │ │     bdecode_node () = default;
│ │ │ │ -   bdecode_node (bdecode_node const&);
│ │ │ │     bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │     bdecode_node (bdecode_node&&) noexcept;
│ │ │ │     bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +   bdecode_node (bdecode_node const&);
│ │ │ │     type_t type () const noexcept;
│ │ │ │     explicit operator bool () const noexcept;
│ │ │ │     bdecode_node non_owning () const;
│ │ │ │     span<char const> data_section () const noexcept;
│ │ │ │     std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ -   int list_size () const;
│ │ │ │ -   string_view list_string_value_at (int i
│ │ │ │ -      , string_view default_val = string_view()) const;
│ │ │ │ -   bdecode_node list_at (int i) const;
│ │ │ │     std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ +   bdecode_node list_at (int i) const;
│ │ │ │ +   string_view list_string_value_at (int i
│ │ │ │ +      , string_view default_val = string_view()) const;
│ │ │ │ +   int list_size () const;
│ │ │ │     int dict_size () const;
│ │ │ │ -   std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +   std::int64_t dict_find_int_value (string_view key
│ │ │ │ +      , std::int64_t default_val = 0) const;
│ │ │ │ +   bdecode_node dict_find (string_view key) const;
│ │ │ │     std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ -   bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +   std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │     bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_string (string_view key) const;
│ │ │ │     bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -   bdecode_node dict_find (string_view key) const;
│ │ │ │ -   std::int64_t dict_find_int_value (string_view key
│ │ │ │ -      , std::int64_t default_val = 0) const;
│ │ │ │     string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │     bdecode_node dict_find_int (string_view key) const;
│ │ │ │     std::int64_t int_value () const;
│ │ │ │ -   char const* string_ptr () const;
│ │ │ │ -   std::ptrdiff_t string_offset () const;
│ │ │ │     int string_length () const;
│ │ │ │ +   std::ptrdiff_t string_offset () const;
│ │ │ │ +   char const* string_ptr () const;
│ │ │ │     string_view string_value () const;
│ │ │ │     void clear ();
│ │ │ │     void swap (bdecode_node& n);
│ │ │ │     void reserve (int tokens);
│ │ │ │     void switch_underlying_buffer (char const* buf) noexcept;
│ │ │ │     bool has_soft_error (span<char> error) const;
│ │ │ │  
│ │ │ │ @@ -19823,18 +19823,18 @@
│ │ │ │  
    
│ │ │ │  
    creates a default constructed node, it will have the type none_t.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    bdecode_node() operator=()
    
│ │ │ │  
    │ │ │ │ -bdecode_node (bdecode_node const&);
│ │ │ │  bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │  bdecode_node (bdecode_node&&) noexcept;
│ │ │ │  bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +bdecode_node (bdecode_node const&);
│ │ │ │  
    
│ │ │ │  
    For owning nodes, the copy will create a copy of the tree, but the
│ │ │ │  underlying buffer remains the same.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    type()
    
│ │ │ │  
    │ │ │ │ @@ -19852,68 +19852,68 @@
│ │ │ │  
    
│ │ │ │  
    non_owning()
    
│ │ │ │  
    │ │ │ │  bdecode_node non_owning () const;
│ │ │ │  
    
│ │ │ │  
    return a non-owning reference to this node. This is useful to refer to
│ │ │ │  the root node without copying it in assignments.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    data_section() data_offset()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    data_offset() data_section()
    
│ │ │ │  
    │ │ │ │  span<char const> data_section () const noexcept;
│ │ │ │  std::ptrdiff_t data_offset () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns the buffer and length of the section in the original bencoded
│ │ │ │  buffer where this node is defined. For a dictionary for instance, this
│ │ │ │  starts with d and ends with e, and has all the content of the
│ │ │ │  dictionary in between.
│ │ │ │  the data_offset() function returns the byte-offset to this node in,
│ │ │ │  starting from the beginning of the buffer that was parsed.
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    list_at() list_string_value_at() list_int_value_at() list_size()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    list_int_value_at() list_string_value_at() list_size() list_at()
    
│ │ │ │  
    │ │ │ │ -int list_size () const;
│ │ │ │ -string_view list_string_value_at (int i
│ │ │ │ -      , string_view default_val = string_view()) const;
│ │ │ │ -bdecode_node list_at (int i) const;
│ │ │ │  std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │ +string_view list_string_value_at (int i
│ │ │ │ +      , string_view default_val = string_view()) const;
│ │ │ │ +int list_size () const;
│ │ │ │  
    
│ │ │ │  
    functions with the list_ prefix operate on lists. These functions are
│ │ │ │  only valid if type() == list_t. list_at() returns the item
│ │ │ │  in the list at index i. i may not be greater than or equal to the
│ │ │ │  size of the list. size() returns the size of the list.
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    dict_at() dict_find_int_value() dict_size() dict_find_int() dict_find_string_value() dict_find() dict_at_node() dict_find_string() dict_find_dict() dict_find_list()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    dict_find_dict() dict_at_node() dict_find() dict_at() dict_find_string() dict_find_list() dict_find_string_value() dict_find_int() dict_find_int_value() dict_size()
    
│ │ │ │  
    │ │ │ │  int dict_size () const;
│ │ │ │ -std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +std::int64_t dict_find_int_value (string_view key
│ │ │ │ +      , std::int64_t default_val = 0) const;
│ │ │ │ +bdecode_node dict_find (string_view key) const;
│ │ │ │  std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ -bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │  bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +bdecode_node dict_find_string (string_view key) const;
│ │ │ │  bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -bdecode_node dict_find (string_view key) const;
│ │ │ │ -std::int64_t dict_find_int_value (string_view key
│ │ │ │ -      , std::int64_t default_val = 0) const;
│ │ │ │  string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │  bdecode_node dict_find_int (string_view key) const;
│ │ │ │  
    
│ │ │ │  
    Functions with the dict_ prefix operates on dictionaries. They are
│ │ │ │  only valid if type() == dict_t. In case a key you're looking up
│ │ │ │  contains a 0 byte, you cannot use the 0-terminated string overloads,
│ │ │ │ @@ -19931,24 +19931,24 @@
│ │ │ │  
    
│ │ │ │  
    int_value()
    
│ │ │ │  
    │ │ │ │  std::int64_t int_value () const;
│ │ │ │  
    
│ │ │ │  
    this function is only valid if type() == int_t. It returns the
│ │ │ │  value of the integer.
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    string_length() string_value() string_offset() string_ptr()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    string_offset() string_ptr() string_length() string_value()
    
│ │ │ │  
    │ │ │ │ -char const* string_ptr () const;
│ │ │ │ -std::ptrdiff_t string_offset () const;
│ │ │ │  int string_length () const;
│ │ │ │ +std::ptrdiff_t string_offset () const;
│ │ │ │ +char const* string_ptr () const;
│ │ │ │  string_view string_value () const;
│ │ │ │  
    
│ │ │ │  
    these functions are only valid if type() == string_t. They return
│ │ │ │  the string values. Note that string_ptr() is not 0-terminated.
│ │ │ │  string_length() returns the number of bytes in the string.
│ │ │ │  string_offset() returns the byte offset from the start of the parsed
│ │ │ │  bencoded buffer this string can be found.
    
│ │ │ │ @@ -20388,21 +20388,21 @@
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    read_resume_data()
    
│ │ │ │  
    Declared in "libtorrent/read_resume_data.hpp"
    
│ │ │ │  
    │ │ │ │  add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ +   , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ +add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │     , load_torrent_limits const& cfg = {});
│ │ │ │  add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │     , int piece_limit = 0x200000);
│ │ │ │  add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │     , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ -add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ -   , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │  
    
│ │ │ │  
    these functions are used to parse resume data and populate the appropriate
│ │ │ │  fields in an add_torrent_params object. This object can then be used to add
│ │ │ │  the actual torrent_info object to and pass to session::add_torrent() or
│ │ │ │  session::async_add_torrent().
    
│ │ │ │  
    If the client wants to override any field that was loaded from the resume
│ │ │ │  data, e.g. save_path, those fields must be changed after loading resume
│ │ │ │ @@ -20410,35 +20410,35 @@
│ │ │ │  
    The piece_limit parameter determines the largest number of pieces
│ │ │ │  allowed in the torrent that may be loaded as part of the resume data, if
│ │ │ │  it contains an info field. The overloads that take a flat buffer are
│ │ │ │  instead configured with limits on torrent sizes via load_torrent limits.
    
│ │ │ │  
    In order to support large torrents, it may also be necessary to raise the
│ │ │ │  settings_pack::max_piece_count setting and pass a higher limit to calls
│ │ │ │  to torrent_info::parse_info_section().
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    write_resume_data() write_resume_data_buf()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    write_resume_data_buf() write_resume_data()
    
│ │ │ │  
    Declared in "libtorrent/write_resume_data.hpp"
    
│ │ │ │  
    │ │ │ │ -entry write_resume_data (add_torrent_params const& atp);
│ │ │ │  std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │ +entry write_resume_data (add_torrent_params const& atp);
│ │ │ │  
    
│ │ │ │  
    this function turns the resume data in an add_torrent_params object
│ │ │ │  into a bencoded structure
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    write_torrent_file_buf() write_torrent_file()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    write_torrent_file() write_torrent_file_buf()
    
│ │ │ │  
    Declared in "libtorrent/write_resume_data.hpp"
    
│ │ │ │  
    │ │ │ │ -entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │  std::vector<char> write_torrent_file_buf (add_torrent_params const& atp
│ │ │ │     , write_torrent_flags_t flags);
│ │ │ │  entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │  
    
│ │ │ │  
    writes only the fields to create a .torrent file. This function may fail
│ │ │ │  with a std::system_error exception if:
    
│ │ │ │  
      
│ │ │ │  
    • The add_torrent_params object passed to this function does not contain the
│ │ │ │  info dictionary (the ti field)
      • 
│ │ │ │  
    • The piece layers are not complete for all files that need them
      • 
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -22,15 +22,15 @@
│ │ │ │ │      * _e_n_u_m_ _s_o_c_k_s___e_r_r_o_r___c_o_d_e
│ │ │ │ │      * _e_n_u_m_ _p_c_p___e_r_r_o_r_s
│ │ │ │ │      * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ │      * _s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ │            o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │            o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │      * _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ -          o _o_p_e_r_a_t_o_r_=_(_)_ _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_)
│ │ │ │ │ +          o _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_)
│ │ │ │ │      * _s_e_s_s_i_o_n
│ │ │ │ │            o _s_e_s_s_i_o_n_(_)
│ │ │ │ │            o _s_e_s_s_i_o_n_(_)
│ │ │ │ │            o _~_s_e_s_s_i_o_n_(_)
│ │ │ │ │            o _a_b_o_r_t_(_)
│ │ │ │ │      * _s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ @@ -38,61 +38,61 @@
│ │ │ │ │            o _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)
│ │ │ │ │            o _p_o_s_t___t_o_r_r_e_n_t___u_p_d_a_t_e_s_(_)
│ │ │ │ │            o _p_o_s_t___s_e_s_s_i_o_n___s_t_a_t_s_(_)
│ │ │ │ │            o _p_o_s_t___d_h_t___s_t_a_t_s_(_)
│ │ │ │ │            o _s_e_t___d_h_t___s_t_a_t_e_(_)
│ │ │ │ │            o _g_e_t___t_o_r_r_e_n_t_s_(_)_ _f_i_n_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │            o _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)_ _a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ -          o _i_s___p_a_u_s_e_d_(_)_ _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ +          o _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)_ _i_s___p_a_u_s_e_d_(_)
│ │ │ │ │            o _i_s___d_h_t___r_u_n_n_i_n_g_(_)
│ │ │ │ │            o _s_e_t___d_h_t___s_t_o_r_a_g_e_(_)
│ │ │ │ │            o _a_d_d___d_h_t___n_o_d_e_(_)
│ │ │ │ │            o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │            o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │            o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │            o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ -          o _d_h_t___g_e_t___p_e_e_r_s_(_)_ _d_h_t___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ +          o _d_h_t___a_n_n_o_u_n_c_e_(_)_ _d_h_t___g_e_t___p_e_e_r_s_(_)
│ │ │ │ │            o _d_h_t___l_i_v_e___n_o_d_e_s_(_)
│ │ │ │ │            o _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s_(_)
│ │ │ │ │            o _d_h_t___d_i_r_e_c_t___r_e_q_u_e_s_t_(_)
│ │ │ │ │            o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │            o _s_e_t___i_p___f_i_l_t_e_r_(_)_ _g_e_t___i_p___f_i_l_t_e_r_(_)
│ │ │ │ │            o _s_e_t___p_o_r_t___f_i_l_t_e_r_(_)
│ │ │ │ │ -          o _i_s___l_i_s_t_e_n_i_n_g_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)
│ │ │ │ │ +          o _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)
│ │ │ │ │            o _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)
│ │ │ │ │            o _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)
│ │ │ │ │            o _c_r_e_a_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │            o _d_e_l_e_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ -          o _s_e_t___p_e_e_r___c_l_a_s_s_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ +          o _g_e_t___p_e_e_r___c_l_a_s_s_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │            o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ │            o _a_p_p_l_y___s_e_t_t_i_n_g_s_(_)_ _g_e_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ -          o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _p_o_p___a_l_e_r_t_s_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)
│ │ │ │ │ +          o _p_o_p___a_l_e_r_t_s_(_)_ _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)
│ │ │ │ │            o _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)_ _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │            o _r_e_o_p_e_n___n_e_t_w_o_r_k___s_o_c_k_e_t_s_(_)
│ │ │ │ │            o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ -    * _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │ +    * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │      * _w_e_b___s_e_e_d___e_n_t_r_y
│ │ │ │ │            o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │            o _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │            o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │      * _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │      * _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │            o _t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │            o _~_t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ -          o _f_i_l_e_s_(_)_ _o_r_i_g___f_i_l_e_s_(_)
│ │ │ │ │ +          o _o_r_i_g___f_i_l_e_s_(_)_ _f_i_l_e_s_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │            o _r_e_m_a_p___f_i_l_e_s_(_)
│ │ │ │ │ -          o _t_r_a_c_k_e_r_s_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ +          o _a_d_d___t_r_a_c_k_e_r_(_)_ _t_r_a_c_k_e_r_s_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │            o _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_)
│ │ │ │ │ -          o _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)
│ │ │ │ │ +          o _a_d_d___u_r_l___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)
│ │ │ │ │            o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ -          o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ +          o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │            o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ -          o _l_a_s_t___p_i_e_c_e_(_)_ _e_n_d___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ -          o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ +          o _e_n_d___p_i_e_c_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ +          o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │            o _v_1_(_)_ _v_2_(_)
│ │ │ │ │            o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │            o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │            o _m_a_p___f_i_l_e_(_)
│ │ │ │ │            o _s_s_l___c_e_r_t_(_)
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _p_r_i_v_(_)
│ │ │ │ │ @@ -110,15 +110,15 @@
│ │ │ │ │            o _i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │            o _p_i_e_c_e___l_a_y_e_r_(_)
│ │ │ │ │            o _f_r_e_e___p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │      * _p_e_e_r___i_n_f_o
│ │ │ │ │            o _i_2_p___d_e_s_t_i_n_a_t_i_o_n_(_)
│ │ │ │ │      * _i_n_f_o___h_a_s_h___t
│ │ │ │ │            o _i_n_f_o___h_a_s_h___t_(_)
│ │ │ │ │ -          o _h_a_s_(_)_ _h_a_s___v_2_(_)_ _h_a_s___v_1_(_)
│ │ │ │ │ +          o _h_a_s___v_2_(_)_ _h_a_s_(_)_ _h_a_s___v_1_(_)
│ │ │ │ │            o _g_e_t_(_)
│ │ │ │ │            o _g_e_t___b_e_s_t_(_)
│ │ │ │ │            o _f_o_r___e_a_c_h_(_)
│ │ │ │ │      * _p_i_e_c_e___b_l_o_c_k
│ │ │ │ │      * _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │            o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │      * _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)_ _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)_ _l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)
│ │ │ │ │ @@ -151,95 +151,95 @@
│ │ │ │ │            o _o_n___a_l_e_r_t_(_)
│ │ │ │ │            o _o_n___u_n_k_n_o_w_n___t_o_r_r_e_n_t_(_)
│ │ │ │ │            o _o_n___t_i_c_k_(_)
│ │ │ │ │            o _g_e_t___u_n_c_h_o_k_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │            o _l_o_a_d___s_t_a_t_e_(_)
│ │ │ │ │      * _t_o_r_r_e_n_t___p_l_u_g_i_n
│ │ │ │ │            o _n_e_w___c_o_n_n_e_c_t_i_o_n_(_)
│ │ │ │ │ -          o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)
│ │ │ │ │ +          o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │            o _t_i_c_k_(_)
│ │ │ │ │ -          o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_e_(_)
│ │ │ │ │ +          o _o_n___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_)
│ │ │ │ │            o _o_n___f_i_l_e_s___c_h_e_c_k_e_d_(_)
│ │ │ │ │            o _o_n___s_t_a_t_e_(_)
│ │ │ │ │            o _o_n___a_d_d___p_e_e_r_(_)
│ │ │ │ │      * _p_e_e_r___p_l_u_g_i_n
│ │ │ │ │            o _t_y_p_e_(_)
│ │ │ │ │            o _a_d_d___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │            o _o_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │            o _o_n___c_o_n_n_e_c_t_e_d_(_)
│ │ │ │ │            o _o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │            o _o_n___e_x_t_e_n_s_i_o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ -          o _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___h_a_v_e_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)
│ │ │ │ │ -            _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___u_n_c_h_o_k_e_(_)
│ │ │ │ │ -            _o_n___c_h_o_k_e_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___r_e_q_u_e_s_t_(_)
│ │ │ │ │ +          o _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___u_n_c_h_o_k_e_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___h_a_v_e_(_)_ _o_n___h_a_v_e___a_l_l_(_)
│ │ │ │ │ +            _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ +            _o_n___r_e_q_u_e_s_t_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)
│ │ │ │ │            o _o_n___p_i_e_c_e_(_)
│ │ │ │ │ -          o _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ +          o _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │              _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │            o _s_e_n_t___p_a_y_l_o_a_d_(_)
│ │ │ │ │            o _c_a_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │            o _o_n___e_x_t_e_n_d_e_d_(_)
│ │ │ │ │            o _o_n___u_n_k_n_o_w_n___m_e_s_s_a_g_e_(_)
│ │ │ │ │ -          o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)
│ │ │ │ │ +          o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │            o _t_i_c_k_(_)
│ │ │ │ │            o _w_r_i_t_e___r_e_q_u_e_s_t_(_)
│ │ │ │ │      * _c_r_y_p_t_o___p_l_u_g_i_n
│ │ │ │ │            o _d_e_c_r_y_p_t_(_)
│ │ │ │ │      * _p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e
│ │ │ │ │      * _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e
│ │ │ │ │      * _c_r_e_a_t_e___u_t___p_e_x___p_l_u_g_i_n_(_)
│ │ │ │ │      * _c_r_e_a_t_e___s_m_a_r_t___b_a_n___p_l_u_g_i_n_(_)
│ │ │ │ │      * _c_r_e_a_t_e___u_t___m_e_t_a_d_a_t_a___p_l_u_g_i_n_(_)
│ │ │ │ │      * _f_i_l_e___s_l_i_c_e
│ │ │ │ │      * _f_i_l_e___s_t_o_r_a_g_e
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _r_e_s_e_r_v_e_(_)
│ │ │ │ │ -          o _a_d_d___f_i_l_e_(_)_ _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)
│ │ │ │ │ +          o _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)_ _a_d_d___f_i_l_e_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │            o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │            o _m_a_p___f_i_l_e_(_)
│ │ │ │ │            o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │            o _e_n_d___f_i_l_e_(_)
│ │ │ │ │            o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │            o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ -          o _n_u_m___p_i_e_c_e_s_(_)_ _s_e_t___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ +          o _s_e_t___n_u_m___p_i_e_c_e_s_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │            o _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │            o _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │            o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ -          o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ +          o _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │            o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │            o _p_i_e_c_e___s_i_z_e_2_(_)
│ │ │ │ │            o _b_l_o_c_k_s___i_n___p_i_e_c_e_2_(_)
│ │ │ │ │            o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │            o _s_e_t___n_a_m_e_(_)_ _n_a_m_e_(_)
│ │ │ │ │            o _s_w_a_p_(_)
│ │ │ │ │            o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ -          o _h_a_s_h_(_)_ _r_o_o_t_(_)_ _m_t_i_m_e_(_)_ _f_i_l_e___s_i_z_e_(_)_ _f_i_l_e___n_a_m_e_(_)_ _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ -            _f_i_l_e___o_f_f_s_e_t_(_)_ _s_y_m_l_i_n_k_(_)_ _r_o_o_t___p_t_r_(_)_ _p_a_d___f_i_l_e___a_t_(_)
│ │ │ │ │ -          o _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ +          o _f_i_l_e___n_a_m_e_(_)_ _h_a_s_h_(_)_ _m_t_i_m_e_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___p_a_t_h_(_)_ _r_o_o_t_(_)_ _s_y_m_l_i_n_k_(_)
│ │ │ │ │ +            _f_i_l_e___s_i_z_e_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)
│ │ │ │ │ +          o _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │            o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)
│ │ │ │ │            o _f_i_l_e___p_a_t_h___h_a_s_h_(_)
│ │ │ │ │            o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │            o _f_i_l_e___f_l_a_g_s_(_)
│ │ │ │ │            o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_)
│ │ │ │ │ -          o _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)_ _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)
│ │ │ │ │ +          o _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)_ _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)
│ │ │ │ │            o _f_i_l_e___i_n_d_e_x___f_o_r___r_o_o_t_(_)
│ │ │ │ │            o _p_i_e_c_e___i_n_d_e_x___a_t___f_i_l_e_(_)
│ │ │ │ │            o _s_a_n_i_t_i_z_e___s_y_m_l_i_n_k_s_(_)
│ │ │ │ │            o _v_2_(_)
│ │ │ │ │      * _s_t_o_r_a_g_e___p_a_r_a_m_s
│ │ │ │ │      * _d_i_s_a_b_l_e_d___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │      * _m_m_a_p___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │      * _p_o_s_i_x___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │      * _d_e_f_a_u_l_t___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │      * _e_n_u_m_ _s_t_o_r_a_g_e___m_o_d_e___t
│ │ │ │ │      * _e_n_u_m_ _s_t_a_t_u_s___t
│ │ │ │ │      * _e_n_u_m_ _m_o_v_e___f_l_a_g_s___t
│ │ │ │ │      * _c_l_i_e_n_t___d_a_t_a___t
│ │ │ │ │            o _c_l_i_e_n_t___d_a_t_a___t_(_)
│ │ │ │ │ -          o _o_p_e_r_a_t_o_r_=_(_)_ _c_o_n_s_t_*_(_)_ _v_o_i_d_*_(_)
│ │ │ │ │ +          o _v_o_i_d_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _c_o_n_s_t_*_(_)
│ │ │ │ │      * _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │      * _p_e_e_r___c_l_a_s_s___i_n_f_o
│ │ │ │ │      * _p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r
│ │ │ │ │            o _r_e_m_o_v_e_(_)_ _a_d_d_(_)
│ │ │ │ │            o _a_l_l_o_w_(_)_ _d_i_s_a_l_l_o_w_(_)
│ │ │ │ │            o _a_p_p_l_y_(_)
│ │ │ │ │            o _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ @@ -249,53 +249,53 @@
│ │ │ │ │      * _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o
│ │ │ │ │      * _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │            o _t_o_r_r_e_n_t___h_a_n_d_l_e_(_)
│ │ │ │ │            o _a_d_d___p_i_e_c_e_(_)
│ │ │ │ │            o _r_e_a_d___p_i_e_c_e_(_)
│ │ │ │ │            o _h_a_v_e___p_i_e_c_e_(_)
│ │ │ │ │            o _g_e_t___p_e_e_r___i_n_f_o_(_)_ _p_o_s_t___p_e_e_r___i_n_f_o_(_)
│ │ │ │ │ -          o _p_o_s_t___s_t_a_t_u_s_(_)_ _s_t_a_t_u_s_(_)
│ │ │ │ │ +          o _s_t_a_t_u_s_(_)_ _p_o_s_t___s_t_a_t_u_s_(_)
│ │ │ │ │            o _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │            o _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ │ -          o _f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ +          o _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │            o _f_i_l_e___s_t_a_t_u_s_(_)
│ │ │ │ │            o _c_l_e_a_r___e_r_r_o_r_(_)
│ │ │ │ │ -          o _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ +          o _a_d_d___t_r_a_c_k_e_r_(_)_ _t_r_a_c_k_e_r_s_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │            o _a_d_d___u_r_l___s_e_e_d_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)
│ │ │ │ │            o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)
│ │ │ │ │            o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │            o _s_e_t___m_e_t_a_d_a_t_a_(_)
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ -          o _f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)
│ │ │ │ │ +          o _s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)
│ │ │ │ │            o _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │            o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │            o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │            o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ -          o _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │ -            _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │ +          o _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)
│ │ │ │ │ +            _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │            o _q_u_e_u_e___p_o_s_i_t_i_o_n___s_e_t_(_)
│ │ │ │ │            o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)
│ │ │ │ │            o _t_o_r_r_e_n_t___f_i_l_e_(_)_ _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │            o _p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │            o _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ -          o _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)
│ │ │ │ │ -          o _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)
│ │ │ │ │ -          o _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ +          o _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ +          o _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ +          o _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │            o _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ -          o _u_p_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ -            _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +          o _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +            _u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │            o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │            o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │            o _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)_ _m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ -          o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ +          o _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │            o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ -          o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ -          o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ +          o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ +          o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)
│ │ │ │ │            o _i_d_(_)
│ │ │ │ │            o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │            o _u_s_e_r_d_a_t_a_(_)
│ │ │ │ │            o _i_n___s_e_s_s_i_o_n_(_)
│ │ │ │ │      * _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ │      * _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │      * _d_i_s_k___i_n_t_e_r_f_a_c_e
│ │ │ │ │ @@ -376,15 +376,15 @@
│ │ │ │ │      * _p_i_e_c_e___f_i_n_i_s_h_e_d___a_l_e_r_t
│ │ │ │ │      * _r_e_q_u_e_s_t___d_r_o_p_p_e_d___a_l_e_r_t
│ │ │ │ │      * _b_l_o_c_k___t_i_m_e_o_u_t___a_l_e_r_t
│ │ │ │ │      * _b_l_o_c_k___f_i_n_i_s_h_e_d___a_l_e_r_t
│ │ │ │ │      * _b_l_o_c_k___d_o_w_n_l_o_a_d_i_n_g___a_l_e_r_t
│ │ │ │ │      * _u_n_w_a_n_t_e_d___b_l_o_c_k___a_l_e_r_t
│ │ │ │ │      * _s_t_o_r_a_g_e___m_o_v_e_d___a_l_e_r_t
│ │ │ │ │ -          o _s_t_o_r_a_g_e___p_a_t_h_(_)_ _o_l_d___p_a_t_h_(_)
│ │ │ │ │ +          o _o_l_d___p_a_t_h_(_)_ _s_t_o_r_a_g_e___p_a_t_h_(_)
│ │ │ │ │      * _s_t_o_r_a_g_e___m_o_v_e_d___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │            o _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │      * _t_o_r_r_e_n_t___d_e_l_e_t_e_d___a_l_e_r_t
│ │ │ │ │      * _t_o_r_r_e_n_t___d_e_l_e_t_e___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │      * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t
│ │ │ │ │      * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │      * _t_o_r_r_e_n_t___p_a_u_s_e_d___a_l_e_r_t
│ │ │ │ │ @@ -452,15 +452,15 @@
│ │ │ │ │      * _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t
│ │ │ │ │      * _p_i_c_k_e_r___l_o_g___a_l_e_r_t
│ │ │ │ │      * _s_e_s_s_i_o_n___e_r_r_o_r___a_l_e_r_t
│ │ │ │ │      * _d_h_t___l_i_v_e___n_o_d_e_s___a_l_e_r_t
│ │ │ │ │            o _n_u_m___n_o_d_e_s_(_)_ _n_o_d_e_s_(_)
│ │ │ │ │      * _s_e_s_s_i_o_n___s_t_a_t_s___h_e_a_d_e_r___a_l_e_r_t
│ │ │ │ │      * _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s___a_l_e_r_t
│ │ │ │ │ -          o _s_a_m_p_l_e_s_(_)_ _n_u_m___s_a_m_p_l_e_s_(_)
│ │ │ │ │ +          o _n_u_m___s_a_m_p_l_e_s_(_)_ _s_a_m_p_l_e_s_(_)
│ │ │ │ │            o _n_u_m___n_o_d_e_s_(_)
│ │ │ │ │            o _n_o_d_e_s_(_)
│ │ │ │ │      * _b_l_o_c_k___u_p_l_o_a_d_e_d___a_l_e_r_t
│ │ │ │ │      * _a_l_e_r_t_s___d_r_o_p_p_e_d___a_l_e_r_t
│ │ │ │ │      * _s_o_c_k_s_5___a_l_e_r_t
│ │ │ │ │      * _f_i_l_e___p_r_i_o___a_l_e_r_t
│ │ │ │ │      * _o_v_e_r_s_i_z_e_d___f_i_l_e___a_l_e_r_t
│ │ │ │ │ @@ -472,15 +472,15 @@
│ │ │ │ │      * _t_r_a_c_k_e_r___l_i_s_t___a_l_e_r_t
│ │ │ │ │      * _a_l_e_r_t___c_a_s_t_(_)
│ │ │ │ │      * _o_p_e_r_a_t_i_o_n___n_a_m_e_(_)
│ │ │ │ │      * _e_n_u_m_ _o_p_e_r_a_t_i_o_n___t
│ │ │ │ │      * _a_l_e_r_t___c_a_t_e_g_o_r_y___t
│ │ │ │ │      * _i_n_t
│ │ │ │ │      * _c_o_u_n_t_e_r_s
│ │ │ │ │ -          o _o_p_e_r_a_t_o_r_[_]_(_)_ _i_n_c___s_t_a_t_s___c_o_u_n_t_e_r_(_)
│ │ │ │ │ +          o _i_n_c___s_t_a_t_s___c_o_u_n_t_e_r_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │      * _s_t_a_t_s___m_e_t_r_i_c
│ │ │ │ │      * _s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_)
│ │ │ │ │      * _f_i_n_d___m_e_t_r_i_c___i_d_x_(_)
│ │ │ │ │      * _e_n_u_m_ _m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ │      * _i_p___f_i_l_t_e_r
│ │ │ │ │            o _e_m_p_t_y_(_)
│ │ │ │ │            o _a_d_d___r_u_l_e_(_)
│ │ │ │ │ @@ -493,50 +493,50 @@
│ │ │ │ │            o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ │      * _e_n_t_r_y
│ │ │ │ │            o _t_y_p_e_(_)
│ │ │ │ │            o _e_n_t_r_y_(_)
│ │ │ │ │            o _e_n_t_r_y_(_)
│ │ │ │ │            o _e_n_t_r_y_(_)
│ │ │ │ │            o _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ -          o _i_n_t_e_g_e_r_(_)_ _d_i_c_t_(_)_ _l_i_s_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)
│ │ │ │ │ +          o _s_t_r_i_n_g_(_)_ _i_n_t_e_g_e_r_(_)_ _l_i_s_t_(_)_ _d_i_c_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)
│ │ │ │ │            o _s_w_a_p_(_)
│ │ │ │ │            o _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │            o _f_i_n_d___k_e_y_(_)
│ │ │ │ │            o _t_o___s_t_r_i_n_g_(_)
│ │ │ │ │            o _e_n_u_m_ _d_a_t_a___t_y_p_e
│ │ │ │ │      * _o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ │      * _b_e_n_c_o_d_e_(_)
│ │ │ │ │      * _c_r_e_a_t_e___t_o_r_r_e_n_t
│ │ │ │ │            o _c_r_e_a_t_e___t_o_r_r_e_n_t_(_)
│ │ │ │ │ -          o _g_e_n_e_r_a_t_e_(_)_ _g_e_n_e_r_a_t_e___b_u_f_(_)
│ │ │ │ │ +          o _g_e_n_e_r_a_t_e___b_u_f_(_)_ _g_e_n_e_r_a_t_e_(_)
│ │ │ │ │            o _f_i_l_e_s_(_)
│ │ │ │ │            o _s_e_t___c_o_m_m_e_n_t_(_)
│ │ │ │ │            o _s_e_t___c_r_e_a_t_o_r_(_)
│ │ │ │ │            o _s_e_t___c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ │            o _s_e_t___h_a_s_h_(_)
│ │ │ │ │            o _s_e_t___h_a_s_h_2_(_)
│ │ │ │ │            o _a_d_d___u_r_l___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │            o _a_d_d___n_o_d_e_(_)
│ │ │ │ │            o _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │            o _s_e_t___r_o_o_t___c_e_r_t_(_)
│ │ │ │ │ -          o _p_r_i_v_(_)_ _s_e_t___p_r_i_v_(_)
│ │ │ │ │ +          o _s_e_t___p_r_i_v_(_)_ _p_r_i_v_(_)
│ │ │ │ │            o _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │            o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │            o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │            o _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │            o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ -          o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ +          o _p_i_e_c_e___s_i_z_e_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │            o _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)_ _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)
│ │ │ │ │      * _a_d_d___f_i_l_e_s_(_)
│ │ │ │ │      * _s_e_t___p_i_e_c_e___h_a_s_h_e_s_(_)
│ │ │ │ │      * _b_i_t_f_i_e_l_d
│ │ │ │ │            o _b_i_t_f_i_e_l_d_(_)
│ │ │ │ │            o _a_s_s_i_g_n_(_)
│ │ │ │ │            o _o_p_e_r_a_t_o_r_[_]_(_)_ _g_e_t___b_i_t_(_)
│ │ │ │ │ -          o _s_e_t___b_i_t_(_)_ _c_l_e_a_r___b_i_t_(_)
│ │ │ │ │ +          o _c_l_e_a_r___b_i_t_(_)_ _s_e_t___b_i_t_(_)
│ │ │ │ │            o _a_l_l___s_e_t_(_)
│ │ │ │ │            o _n_o_n_e___s_e_t_(_)
│ │ │ │ │            o _s_i_z_e_(_)
│ │ │ │ │            o _n_u_m___w_o_r_d_s_(_)
│ │ │ │ │            o _n_u_m___b_y_t_e_s_(_)
│ │ │ │ │            o _e_m_p_t_y_(_)
│ │ │ │ │            o _d_a_t_a_(_)
│ │ │ │ │ @@ -546,32 +546,32 @@
│ │ │ │ │            o _f_i_n_d___l_a_s_t___c_l_e_a_r_(_)
│ │ │ │ │      * _h_a_s_h_e_r
│ │ │ │ │            o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_(_)
│ │ │ │ │            o _u_p_d_a_t_e_(_)
│ │ │ │ │            o _f_i_n_a_l_(_)
│ │ │ │ │            o _r_e_s_e_t_(_)
│ │ │ │ │      * _h_a_s_h_e_r_2_5_6
│ │ │ │ │ -          o _h_a_s_h_e_r_2_5_6_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ +          o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_2_5_6_(_)
│ │ │ │ │            o _u_p_d_a_t_e_(_)
│ │ │ │ │            o _f_i_n_a_l_(_)
│ │ │ │ │            o _r_e_s_e_t_(_)
│ │ │ │ │      * _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │            o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │            o _e_n_u_m_ _s_t_a_t_e___t
│ │ │ │ │      * _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │      * _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │      * _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │            o _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)
│ │ │ │ │            o _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e
│ │ │ │ │      * _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │ -          o _s_e_t___b_o_o_l_(_)_ _s_e_t___s_t_r_(_)_ _s_e_t___i_n_t_(_)
│ │ │ │ │ +          o _s_e_t___s_t_r_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_)
│ │ │ │ │            o _h_a_s___v_a_l_(_)
│ │ │ │ │            o _c_l_e_a_r_(_)
│ │ │ │ │            o _c_l_e_a_r_(_)
│ │ │ │ │ -          o _g_e_t___b_o_o_l_(_)_ _g_e_t___i_n_t_(_)_ _g_e_t___s_t_r_(_)
│ │ │ │ │ +          o _g_e_t___s_t_r_(_)_ _g_e_t___i_n_t_(_)_ _g_e_t___b_o_o_l_(_)
│ │ │ │ │            o _e_n_u_m_ _t_y_p_e___b_a_s_e_s
│ │ │ │ │            o _e_n_u_m_ _m_m_a_p___w_r_i_t_e___m_o_d_e___t
│ │ │ │ │            o _e_n_u_m_ _s_u_g_g_e_s_t___m_o_d_e___t
│ │ │ │ │            o _e_n_u_m_ _c_h_o_k_i_n_g___a_l_g_o_r_i_t_h_m___t
│ │ │ │ │            o _e_n_u_m_ _s_e_e_d___c_h_o_k_i_n_g___a_l_g_o_r_i_t_h_m___t
│ │ │ │ │            o _e_n_u_m_ _i_o___b_u_f_f_e_r___m_o_d_e___t
│ │ │ │ │            o _e_n_u_m_ _b_a_n_d_w_i_d_t_h___m_i_x_e_d___a_l_g_o___t
│ │ │ │ │ @@ -584,21 +584,21 @@
│ │ │ │ │      * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │      * _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │            o _b_d_e_c_o_d_e___n_o_d_e_(_)
│ │ │ │ │            o _b_d_e_c_o_d_e___n_o_d_e_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │            o _t_y_p_e_(_)
│ │ │ │ │            o _b_o_o_l_(_)
│ │ │ │ │            o _n_o_n___o_w_n_i_n_g_(_)
│ │ │ │ │ -          o _d_a_t_a___s_e_c_t_i_o_n_(_)_ _d_a_t_a___o_f_f_s_e_t_(_)
│ │ │ │ │ -          o _l_i_s_t___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)
│ │ │ │ │ -          o _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)
│ │ │ │ │ -            _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___a_t___n_o_d_e_(_)
│ │ │ │ │ -            _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)
│ │ │ │ │ +          o _d_a_t_a___o_f_f_s_e_t_(_)_ _d_a_t_a___s_e_c_t_i_o_n_(_)
│ │ │ │ │ +          o _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___a_t_(_)
│ │ │ │ │ +          o _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___a_t___n_o_d_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___a_t_(_)
│ │ │ │ │ +            _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)
│ │ │ │ │ +            _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___s_i_z_e_(_)
│ │ │ │ │            o _i_n_t___v_a_l_u_e_(_)
│ │ │ │ │ -          o _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___p_t_r_(_)
│ │ │ │ │ +          o _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)
│ │ │ │ │            o _c_l_e_a_r_(_)
│ │ │ │ │            o _s_w_a_p_(_)
│ │ │ │ │            o _r_e_s_e_r_v_e_(_)
│ │ │ │ │            o _s_w_i_t_c_h___u_n_d_e_r_l_y_i_n_g___b_u_f_f_e_r_(_)
│ │ │ │ │            o _h_a_s___s_o_f_t___e_r_r_o_r_(_)
│ │ │ │ │            o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │      * _p_r_i_n_t___e_n_t_r_y_(_)
│ │ │ │ │ @@ -618,16 +618,16 @@
│ │ │ │ │            o _g_e_t___i_n_f_o_h_a_s_h_e_s___s_a_m_p_l_e_(_)
│ │ │ │ │            o _t_i_c_k_(_)
│ │ │ │ │            o _c_o_u_n_t_e_r_s_(_)
│ │ │ │ │      * _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │      * _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │      * _a_n_n_o_u_n_c_e___f_l_a_g_s___t
│ │ │ │ │      * _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ -    * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)
│ │ │ │ │ -    * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ +    * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ +    * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)
│ │ │ │ │      * _w_r_i_t_e___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │      * _e_d_2_5_5_1_9___c_r_e_a_t_e___s_e_e_d_(_)
│ │ │ │ │      * _e_d_2_5_5_1_9___c_r_e_a_t_e___k_e_y_p_a_i_r_(_)
│ │ │ │ │      * _e_d_2_5_5_1_9___s_i_g_n_(_)
│ │ │ │ │      * _e_d_2_5_5_1_9___v_e_r_i_f_y_(_)
│ │ │ │ │      * _e_d_2_5_5_1_9___a_d_d___s_c_a_l_a_r_(_)
│ │ │ │ │      * _e_d_2_5_5_1_9___k_e_y___e_x_c_h_a_n_g_e_(_)
│ │ │ │ │ @@ -635,29 +635,29 @@
│ │ │ │ │  ************ ssttoorraaggee__eerrrroorr ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ │  used by storage to return errors also includes which underlying file the error
│ │ │ │ │  happened on
│ │ │ │ │  struct storage_error
│ │ │ │ │  {
│ │ │ │ │     explicit operator bbooooll () const;
│ │ │ │ │ -   void ffiillee (file_index_t f);
│ │ │ │ │     file_index_t ffiillee () const;
│ │ │ │ │ +   void ffiillee (file_index_t f);
│ │ │ │ │  
│ │ │ │ │     error_code ec;
│ │ │ │ │     operation_t operation;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bbooooll(()) **********
│ │ │ │ │  explicit operator bbooooll () const;
│ │ │ │ │  explicitly converts to true if this object represents an error, and false if it
│ │ │ │ │  does not.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee(()) **********
│ │ │ │ │ -void ffiillee (file_index_t f);
│ │ │ │ │  file_index_t ffiillee () const;
│ │ │ │ │ +void ffiillee (file_index_t f);
│ │ │ │ │  set and query the index (in the torrent) of the file this error occurred on.
│ │ │ │ │  This may also have special values defined in _t_o_r_r_e_n_t___s_t_a_t_u_s.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    ec
│ │ │ │ │        the error that occurred
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    operation
│ │ │ │ │ @@ -1238,44 +1238,44 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ sseessssiioonn__ppaarraammss ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │  The _s_e_s_s_i_o_n___p_a_r_a_m_s is a parameters pack for configuring the _s_e_s_s_i_o_n before it's
│ │ │ │ │  started.
│ │ │ │ │  struct session_params
│ │ │ │ │  {
│ │ │ │ │ -   sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ -   sseessssiioonn__ppaarraammss ();
│ │ │ │ │     sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ -   sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ -      , std::vector> exts);
│ │ │ │ │ +   sseessssiioonn__ppaarraammss ();
│ │ │ │ │ +   sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │     sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │        , std::vector> exts);
│ │ │ │ │ +   sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ +      , std::vector> exts);
│ │ │ │ │  
│ │ │ │ │     settings_pack settings;
│ │ │ │ │     std::vector> extensions;
│ │ │ │ │     dht::dht_state dht_state;
│ │ │ │ │     dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │ │     disk_io_constructor_type disk_io_constructor;
│ │ │ │ │     std::map ext_state;
│ │ │ │ │     libtorrent::ip_filter ip_filter;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ -sseessssiioonn__ppaarraammss ();
│ │ │ │ │  sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ +sseessssiioonn__ppaarraammss ();
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │  This constructor can be used to start with the default plugins (ut_metadata,
│ │ │ │ │  ut_pex and smart_ban). Pass a _s_e_t_t_i_n_g_s___p_a_c_k to set the initial settings when
│ │ │ │ │  the _s_e_s_s_i_o_n starts.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ -      , std::vector> exts);
│ │ │ │ │  sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │        , std::vector> exts);
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ +      , std::vector> exts);
│ │ │ │ │  This constructor helps to configure the set of initial plugins to be added to
│ │ │ │ │  the _s_e_s_s_i_o_n before it's started.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    settings
│ │ │ │ │        The settings to configure the _s_e_s_s_i_o_n with
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    extensions
│ │ │ │ │ @@ -1306,29 +1306,29 @@
│ │ │ │ │  _s_e_s_s_i_o_n destruction is explicitly initiated, this holder is used to synchronize
│ │ │ │ │  the completion of the shutdown. The lifetime of this object may outlive
│ │ │ │ │  _s_e_s_s_i_o_n, causing the _s_e_s_s_i_o_n destructor to not block. The _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │  destructor will block however, until the underlying _s_e_s_s_i_o_n is done shutting
│ │ │ │ │  down.
│ │ │ │ │  struct session_proxy
│ │ │ │ │  {
│ │ │ │ │ +   session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │     sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ -   sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ +   session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │     ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │     sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ -   session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ -   session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ +   sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr==(()) ~~sseessssiioonn__pprrooxxyy(()) sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ +********** ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ +session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │  sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ -sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ +session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │  ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │  sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ +sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │  default constructor, does not refer to any _s_e_s_s_i_o_n implementation object.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ sseessssiioonn ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p"
│ │ │ │ │  The _s_e_s_s_i_o_n holds all state that spans multiple torrents. Among other things it
│ │ │ │ │  runs the network loop and manages all torrents. Once it's created, the _s_e_s_s_i_o_n
│ │ │ │ │  object will spawn the main thread that will do all the work. The main thread
│ │ │ │ │ @@ -1336,47 +1336,47 @@
│ │ │ │ │  You have some control over _s_e_s_s_i_o_n configuration through the session_handle::
│ │ │ │ │  apply_settings() member function. To change one or more configuration options,
│ │ │ │ │  create a _s_e_t_t_i_n_g_s___p_a_c_k. object and fill it with the settings to be set and pass
│ │ │ │ │  it in to session::apply_settings().
│ │ │ │ │  see _a_p_p_l_y___s_e_t_t_i_n_g_s_(_).
│ │ │ │ │  struct session : session_handle
│ │ │ │ │  {
│ │ │ │ │ -   sseessssiioonn ();
│ │ │ │ │     explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ -   sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │     sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ +   sseessssiioonn ();
│ │ │ │ │     explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ -   sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ +   sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │     sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ -   sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ +   sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │     sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ +   sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │     ~~sseessssiioonn ();
│ │ │ │ │     session_proxy aabboorrtt ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn ();
│ │ │ │ │  explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ -sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │  sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ +sseessssiioonn ();
│ │ │ │ │  explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ +sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │  Constructs the _s_e_s_s_i_o_n objects which acts as the container of torrents. In
│ │ │ │ │  order to avoid a race condition between starting the _s_e_s_s_i_o_n and configuring
│ │ │ │ │  it, you can pass in a _s_e_s_s_i_o_n___p_a_r_a_m_s object. Its settings will take effect
│ │ │ │ │  before the _s_e_s_s_i_o_n starts up.
│ │ │ │ │  The overloads taking flags can be used to start a _s_e_s_s_i_o_n in paused mode (by
│ │ │ │ │  passing in session::paused). Note that add_default_plugins do not have an
│ │ │ │ │  affect on constructors that take a _s_e_s_s_i_o_n___p_a_r_a_m_s object. It already contains
│ │ │ │ │  the plugins to use.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │  sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ +sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │  sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │  Overload of the constructor that takes an external io_context to run the
│ │ │ │ │  _s_e_s_s_i_o_n object on. This is primarily useful for tests that may want to run
│ │ │ │ │  multiple sessions on a single io_context, or low resource systems where
│ │ │ │ │  additional threads are expensive and sharing an io_context with other events is
│ │ │ │ │  fine.
│ │ │ │ │  Warning
│ │ │ │ │  The _s_e_s_s_i_o_n object does not cleanly terminate with an external io_context. The
│ │ │ │ │ @@ -1424,28 +1424,28 @@
│ │ │ │ │        , status_flags_t flags = {}) const;
│ │ │ │ │     std::vector ggeett__ttoorrrreenntt__ssttaattuuss (
│ │ │ │ │        std::function const& pred
│ │ │ │ │        , status_flags_t flags = {}) const;
│ │ │ │ │     void ppoosstt__ttoorrrreenntt__uuppddaatteess (status_flags_t flags = status_flags_t::all());
│ │ │ │ │     void ppoosstt__sseessssiioonn__ssttaattss ();
│ │ │ │ │     void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ -   void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │     void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ +   void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │     torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │     std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │     torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ -   torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ -   torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ -   void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │     torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code&
│ │ │ │ │  ec);
│ │ │ │ │ +   void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │     void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ -   void ppaauussee ();
│ │ │ │ │ +   torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ +   torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │     void rreessuummee ();
│ │ │ │ │     bool iiss__ppaauusseedd () const;
│ │ │ │ │ +   void ppaauussee ();
│ │ │ │ │     bool iiss__ddhhtt__rruunnnniinngg () const;
│ │ │ │ │     void sseett__ddhhtt__ssttoorraaggee (dht::dht_storage_constructor_type sc);
│ │ │ │ │     void aadddd__ddhhtt__nnooddee (std::pair const& node);
│ │ │ │ │     void ddhhtt__ggeett__iitteemm (sha1_hash const& target);
│ │ │ │ │     void ddhhtt__ggeett__iitteemm (std::array key
│ │ │ │ │        , std::string salt = std::string());
│ │ │ │ │     sha1_hash ddhhtt__ppuutt__iitteemm (entry data);
│ │ │ │ │ @@ -1457,38 +1457,38 @@
│ │ │ │ │  announce_flags_t flags = {});
│ │ │ │ │     void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │     void ddhhtt__lliivvee__nnooddeess (sha1_hash const& nid);
│ │ │ │ │     void ddhhtt__ssaammppllee__iinnffoohhaasshheess (udp::endpoint const& ep, sha1_hash const&
│ │ │ │ │  target);
│ │ │ │ │     void ddhhtt__ddiirreecctt__rreeqquueesstt (udp::endpoint const& ep, entry const& e,
│ │ │ │ │  client_data_t userdata = {});
│ │ │ │ │ +   void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │     void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ -   void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │     ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ │     void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ │     void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ +   unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │     unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │     bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ -   unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ -   void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │     ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ -   peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ +   void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │     void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ +   peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │     peer_class_t ccrreeaattee__ppeeeerr__ccllaassss (char const* name);
│ │ │ │ │     void ddeelleettee__ppeeeerr__ccllaassss (peer_class_t cid);
│ │ │ │ │ -   peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │     void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ +   peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │     void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ │ +   void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │     void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │     settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ -   void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ -   void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ -   alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │     void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ +   alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ +   void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │     void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │     std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ │  external_port, int local_port);
│ │ │ │ │     void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options =
│ │ │ │ │  reopen_map_ports);
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │  
│ │ │ │ │ @@ -1575,16 +1575,16 @@
│ │ │ │ │  For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppoosstt__ddhhtt__ssttaattss(()) **********
│ │ │ │ │  void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │  This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseett__ddhhtt__ssttaattee(()) **********
│ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │  void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │  set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next
│ │ │ │ │  time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on
│ │ │ │ │  startup.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) **********
│ │ │ │ │  torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │  std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ @@ -1593,19 +1593,19 @@
│ │ │ │ │  case the torrent cannot be found, an invalid _t_o_r_r_e_n_t___h_a_n_d_l_e is returned.
│ │ │ │ │  See torrent_handle::is_valid() to know if the torrent was found or not.
│ │ │ │ │  get_torrents() returns a vector of torrent_handles to all the torrents
│ │ │ │ │  currently in the _s_e_s_s_i_o_n.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aassyynncc__aadddd__ttoorrrreenntt(()) aadddd__ttoorrrreenntt(()) **********
│ │ │ │ │  torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │  torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │  void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │  You add torrents through the _a_d_d___t_o_r_r_e_n_t_(_) function where you give an object
│ │ │ │ │  with all the parameters. The _a_d_d___t_o_r_r_e_n_t_(_) overloads will block until the
│ │ │ │ │  torrent has been added (or failed to be added) and returns an error code and a
│ │ │ │ │  _t_o_r_r_e_n_t___h_a_n_d_l_e. In order to add torrents more efficiently, consider using
│ │ │ │ │  _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) which returns immediately, without waiting for the torrent
│ │ │ │ │  to add. Notification of the torrent being added is sent as _a_d_d___t_o_r_r_e_n_t___a_l_e_r_t.
│ │ │ │ │  The save_path field in _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s must be set to a valid path where the
│ │ │ │ │ @@ -1626,18 +1626,18 @@
│ │ │ │ │  torrent_flags::paused and torrent_flags::auto_managed. In order to add a magnet
│ │ │ │ │  link that will just download the metadata, but no payload, set the
│ │ │ │ │  torrent_flags::upload_mode flag.
│ │ │ │ │  Special consideration has to be taken when adding hybrid torrents (i.e.
│ │ │ │ │  torrents that are BitTorrent v2 torrents that are backwards compatible with
│ │ │ │ │  v1). For more details, see _B_i_t_T_o_r_r_e_n_t_ _v_2_ _t_o_r_r_e_n_t_s.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iiss__ppaauusseedd(()) rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │ -void ppaauussee ();
│ │ │ │ │ +********** rreessuummee(()) ppaauussee(()) iiss__ppaauusseedd(()) **********
│ │ │ │ │  void rreessuummee ();
│ │ │ │ │  bool iiss__ppaauusseedd () const;
│ │ │ │ │ +void ppaauussee ();
│ │ │ │ │  Pausing the _s_e_s_s_i_o_n has the same effect as pausing every torrent in it, except
│ │ │ │ │  that torrents will not be resumed by the auto-manage mechanism. Resuming will
│ │ │ │ │  restore the torrents to their previous paused state. i.e. the _s_e_s_s_i_o_n pause
│ │ │ │ │  state is separate from the torrent pause state. A torrent is inactive if it is
│ │ │ │ │  paused or if the _s_e_s_s_i_o_n is paused.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iiss__ddhhtt__rruunnnniinngg(()) **********
│ │ │ │ │ @@ -1713,15 +1713,15 @@
│ │ │ │ │  and make the function entirely self-contained. The only reason data blob's
│ │ │ │ │  value is computed via a function instead of just passing in the new value is to
│ │ │ │ │  avoid race conditions. If you want to uuppddaattee the value in the DHT, you must
│ │ │ │ │  first retrieve it, then modify it, then write it back. The way the DHT works,
│ │ │ │ │  it is natural to always do a lookup before storing and calling the callback in
│ │ │ │ │  between is convenient.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddhhtt__ggeett__ppeeeerrss(()) ddhhtt__aannnnoouunnccee(()) **********
│ │ │ │ │ +********** ddhhtt__aannnnoouunnccee(()) ddhhtt__ggeett__ppeeeerrss(()) **********
│ │ │ │ │  void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │  announce_flags_t flags = {});
│ │ │ │ │  void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │  dht_get_peers() will issue a DHT get_peer request to the DHT for the specified
│ │ │ │ │  info-hash. The response (the peers) will be posted back in a
│ │ │ │ │  _d_h_t___g_e_t___p_e_e_r_s___r_e_p_l_y___a_l_e_r_t.
│ │ │ │ │  dht_announce() will issue a DHT announce request to the DHT to the specified
│ │ │ │ │ @@ -1756,17 +1756,17 @@
│ │ │ │ │  Send an arbitrary DHT request directly to the specified endpoint. This function
│ │ │ │ │  is intended for use by plugins. When a response is received or the request
│ │ │ │ │  times out, a _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t will be posted with the response (if
│ │ │ │ │  any) and the userdata pointer passed in here. Since this _a_l_e_r_t is a response to
│ │ │ │ │  an explicit call, it will always be posted, regardless of the _a_l_e_r_t mask.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__eexxtteennssiioonn(()) **********
│ │ │ │ │ +void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │  void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ -void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │  This function adds an extension to this _s_e_s_s_i_o_n. The argument is a function
│ │ │ │ │  object that is called with a torrent_handle and which should return a std::
│ │ │ │ │  shared_ptr. To write custom plugins, see _l_i_b_t_o_r_r_e_n_t_ _p_l_u_g_i_n_s.
│ │ │ │ │  For the typical bittorrent client all of these extensions should be added. The
│ │ │ │ │  main plugins implemented in libtorrent are:
│ │ │ │ │    uTorrent metadata
│ │ │ │ │        Allows peers to download the metadata (.torrent files) from the swarm
│ │ │ │ │ @@ -1799,27 +1799,27 @@
│ │ │ │ │  ********** sseett__ppoorrtt__ffiilltteerr(()) **********
│ │ │ │ │  void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │  apply _p_o_r_t___f_i_l_t_e_r f to incoming and outgoing peers. a port filter will reject
│ │ │ │ │  making outgoing peer connections to certain remote ports. The main intention is
│ │ │ │ │  to be able to avoid triggering certain anti-virus software by connecting to
│ │ │ │ │  SMTP, FTP ports.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iiss__lliisstteenniinngg(()) ssssll__lliisstteenn__ppoorrtt(()) lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ +********** ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ +unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │  unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │  bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ -unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │  is_listening() will tell you whether or not the _s_e_s_s_i_o_n has successfully opened
│ │ │ │ │  a listening port. If it hasn't, this function will return false, and then you
│ │ │ │ │  can set a new _s_e_t_t_i_n_g_s___p_a_c_k_:_:_l_i_s_t_e_n___i_n_t_e_r_f_a_c_e_s to try another interface and
│ │ │ │ │  port to bind to.
│ │ │ │ │  listen_port() returns the port we ended up listening on.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) **********
│ │ │ │ │ -void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │  ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ +void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │  Sets the peer class filter for this _s_e_s_s_i_o_n. All new peer connections will take
│ │ │ │ │  this into account and be added to the peer classes specified by this filter,
│ │ │ │ │  based on the peer's IP address.
│ │ │ │ │  The ip-filter essentially maps an IP -> uint32. Each bit in that 32 bit integer
│ │ │ │ │  represents a peer class. The least significant bit represents class 0, the next
│ │ │ │ │  bit class 1 and so on.
│ │ │ │ │  For more info, see _i_p___f_i_l_t_e_r.
│ │ │ │ │ @@ -1837,16 +1837,16 @@
│ │ │ │ │  removed from a peer as a result of this call, peer classes are only added.
│ │ │ │ │  The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ │  peer classes in the peer_class_filter are 32 bits.
│ │ │ │ │  The get_peer_class_filter() function returns the current filter.
│ │ │ │ │  For more information, see _p_e_e_r_ _c_l_a_s_s_e_s.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) **********
│ │ │ │ │ -peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │  void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ +peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │  Sets and gets the ppeeeerr ccllaassss ttyyppee ffiilltteerr. This is controls automatic peer class
│ │ │ │ │  assignments to peers based on what kind of socket it is.
│ │ │ │ │  It does not only support assigning peer classes, it also supports removing peer
│ │ │ │ │  classes based on socket type.
│ │ │ │ │  The order of these rules being applied are:
│ │ │ │ │     1. peer-class IP filter
│ │ │ │ │     2. peer-class type filter, removing classes
│ │ │ │ │ @@ -1874,17 +1874,17 @@
│ │ │ │ │  Since peer classes are reference counted, this function will not remove the
│ │ │ │ │  peer class if it's still assigned to torrents or peers. It will however remove
│ │ │ │ │  it once the last peer and torrent drops their references to it.
│ │ │ │ │  There is no need to call this function for custom peer classes. All peer
│ │ │ │ │  classes will be properly destructed when the _s_e_s_s_i_o_n object destructs.
│ │ │ │ │  For more information on peer classes, see _p_e_e_r_ _c_l_a_s_s_e_s.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss(()) ggeett__ppeeeerr__ccllaassss(()) **********
│ │ │ │ │ -peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss(()) sseett__ppeeeerr__ccllaassss(()) **********
│ │ │ │ │  void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ +peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │  These functions queries information from a peer class and updates the
│ │ │ │ │  configuration of a peer class, respectively.
│ │ │ │ │  cid must refer to an existing peer class. If it does not, the return value of
│ │ │ │ │  get_peer_class() is undefined.
│ │ │ │ │  set_peer_class() sets all the information in the _p_e_e_r___c_l_a_s_s___i_n_f_o object in the
│ │ │ │ │  specified peer class. There is no option to only update a single property.
│ │ │ │ │  A peer or torrent belonging to more than one class, the highest priority among
│ │ │ │ │ @@ -1915,25 +1915,25 @@
│ │ │ │ │  Note that when a queued or downloading torrent is removed, its position in the
│ │ │ │ │  download queue is vacated and every subsequent torrent in the queue has their
│ │ │ │ │  queue positions updated. This can potentially cause a large state_update to be
│ │ │ │ │  posted. When removing all torrents, it is advised to remove them from the back
│ │ │ │ │  of the queue, to minimize the shifting.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aappppllyy__sseettttiinnggss(()) ggeett__sseettttiinnggss(()) **********
│ │ │ │ │ +void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │  void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │  settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ -void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │  Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous
│ │ │ │ │  operation that will return immediately and actually apply the settings to the
│ │ │ │ │  main thread of libtorrent some time later.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__aalleerrtt__nnoottiiffyy(()) ppoopp__aalleerrttss(()) wwaaiitt__ffoorr__aalleerrtt(()) **********
│ │ │ │ │ -void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ -alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ +********** ppoopp__aalleerrttss(()) sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) **********
│ │ │ │ │  void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ +alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ +void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │  Alerts is the main mechanism for libtorrent to report errors and events.
│ │ │ │ │  pop_alerts fills in the vector passed to it with pointers to new alerts. The
│ │ │ │ │  _s_e_s_s_i_o_n still owns these alerts and they will stay valid until the next time
│ │ │ │ │  pop_alerts is called. You may not delete the _a_l_e_r_t objects.
│ │ │ │ │  It is safe to call pop_alerts from multiple different threads, as long as the
│ │ │ │ │  alerts themselves are not accessed once another thread calls pop_alerts. Doing
│ │ │ │ │  this requires manual synchronization between the popping threads.
│ │ │ │ │ @@ -2029,25 +2029,25 @@
│ │ │ │ │        protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    reopen_map_ports
│ │ │ │ │        This option indicates if the ports are mapped using natpmp and upnp. If
│ │ │ │ │        mapping was already made, they are deleted and added again. This only
│ │ │ │ │        works if natpmp and/or upnp are configured to be enable.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(())
│ │ │ │ │ +************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) wwrriittee__sseessssiioonn__ppaarraammss(()) rreeaadd__sseessssiioonn__ppaarraammss(())
│ │ │ │ │  ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ -std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp
│ │ │ │ │ -   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ -entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ -   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │  session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e
│ │ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │  session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ +std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp
│ │ │ │ │ +   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ +entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ +   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │  These functions serialize and de-serialize a session_params object to and from
│ │ │ │ │  bencoded form. The _s_e_s_s_i_o_n___p_a_r_a_m_s object is used to initialize a new _s_e_s_s_i_o_n
│ │ │ │ │  using the state from a previous one (or by programmatically configure the
│ │ │ │ │  _s_e_s_s_i_o_n up-front). The flags parameter can be used to only save and load
│ │ │ │ │  certain aspects of the session's state. The _buf suffix indicates the function
│ │ │ │ │  operates on buffer rather than the bencoded structure. The torrents in a
│ │ │ │ │  _s_e_s_s_i_o_n are not part of the _s_e_s_s_i_o_n___p_a_r_a_m_s state, they have to be restored
│ │ │ │ │ @@ -2129,62 +2129,62 @@
│ │ │ │ │        the max number of bdecode tokens
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ttoorrrreenntt__iinnffoo ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p"
│ │ │ │ │  the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file.
│ │ │ │ │  class torrent_info
│ │ │ │ │  {
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │  cfg);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │     ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │     file_storage const& ffiilleess () const;
│ │ │ │ │     file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │     void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ │ -   void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │     std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +   void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +   void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │     void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ │ -   void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │     std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │     std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ -   void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ +   std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ +   void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │     void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │  headers_t());
│ │ │ │ │ -   std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ -   void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +   void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ -   int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int nnuumm__ppiieecceess () const;
│ │ │ │ │ +   int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ -   piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const;
│ │ │ │ │     piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ -   info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ +   piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ -   bool vv11 () const;
│ │ │ │ │ +   info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │     bool vv22 () const;
│ │ │ │ │ +   bool vv11 () const;
│ │ │ │ │     int nnuumm__ffiilleess () const;
│ │ │ │ │     std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ │        , std::int64_t offset, int size) const;
│ │ │ │ │     peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int
│ │ │ │ │  size) const;
│ │ │ │ │     string_view ssssll__cceerrtt () const;
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │ @@ -2205,29 +2205,29 @@
│ │ │ │ │     bdecode_node iinnffoo (char const* key) const;
│ │ │ │ │     span iinnffoo__sseeccttiioonn () const;
│ │ │ │ │     span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ │     void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │  cfg);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │  The constructor that takes an info-hash will initialize the info-hash to the
│ │ │ │ │  given value, but leave all other fields empty. This is used internally when
│ │ │ │ │  downloading torrents without the metadata. The metadata will be created by
│ │ │ │ │  libtorrent as soon as it has been downloaded from the swarm.
│ │ │ │ │  The constructor that takes a _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │  from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │  represents a tree node in an bencoded file. To load an ordinary .torrent file
│ │ │ │ │ @@ -2250,15 +2250,15 @@
│ │ │ │ │  from_span_t to disambiguate the std::string overload for string literals. There
│ │ │ │ │  is an object in the libtorrent namespace of this type called from_span.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ~~ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │  ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │  frees all storage associated with this _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiilleess(()) oorriigg__ffiilleess(()) **********
│ │ │ │ │ +********** oorriigg__ffiilleess(()) ffiilleess(()) **********
│ │ │ │ │  file_storage const& ffiilleess () const;
│ │ │ │ │  file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │  The _f_i_l_e___s_t_o_r_a_g_e object contains the information on how to map the pieces to
│ │ │ │ │  files. It is separated from the _t_o_r_r_e_n_t___i_n_f_o object because when creating
│ │ │ │ │  torrents a storage object needs to be created without having a torrent file.
│ │ │ │ │  When renaming files in a storage, the storage needs to make its own copy of the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e in order to make its mapping differ from the one in the torrent
│ │ │ │ │ @@ -2293,20 +2293,20 @@
│ │ │ │ │  Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │ │  instance, download all data in a torrent to a single file, or to a number of
│ │ │ │ │  fixed size sector aligned files, regardless of the number and sizes of the
│ │ │ │ │  files in the torrent.
│ │ │ │ │  The new specified file_storage must have the exact same size as the current
│ │ │ │ │  one.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttrraacckkeerrss(()) cclleeaarr__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +********** aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │  std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │  void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │  add_tracker() adds a tracker to the announce-list. The tier determines the
│ │ │ │ │  order in which the trackers are to be tried. The trackers() function will
│ │ │ │ │  return a sorted vector of _a_n_n_o_u_n_c_e___e_n_t_r_y. Each announce _e_n_t_r_y contains a
│ │ │ │ │  string, which is the tracker url, and a tier index. The tier index is the high-
│ │ │ │ │  level priority. No matter which trackers that works or not, the ones with lower
│ │ │ │ │  tier will always be tried before the one with higher tier number. For more
│ │ │ │ │  information, see _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ @@ -2317,25 +2317,25 @@
│ │ │ │ │  std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │  std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │  These two functions are related to _B_E_P_ _3_8 (mutable torrents). The vectors
│ │ │ │ │  returned from these correspond to the "similar" and "collections" keys in the
│ │ │ │ │  .torrent file. Both info-hashes and collections from within the info-dict and
│ │ │ │ │  from outside of it are included.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ +********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) wweebb__sseeeeddss(()) sseett__wweebb__sseeeeddss(()) **********
│ │ │ │ │ +std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ +void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │  void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │        , std::string const& ext_auth = std::string()
│ │ │ │ │        , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │  headers_t());
│ │ │ │ │ -std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │  web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is
│ │ │ │ │  a web_seed_entry and may refer to either a url seed or http seed.
│ │ │ │ │  add_url_seed() and add_http_seed() adds one url to the list of url/http seeds.
│ │ │ │ │  set_web_seeds() replaces all web seeds with the ones specified in the seeds
│ │ │ │ │  vector.
│ │ │ │ │  The extern_auth argument can be used for other authorization schemes than basic
│ │ │ │ │  HTTP authorization. If set, it will override any username and password found in
│ │ │ │ │ @@ -2348,47 +2348,47 @@
│ │ │ │ │  ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │  std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │  total_size() returns the total number of bytes the torrent-file represents.
│ │ │ │ │  Note that this is the number of pieces times the piece size (modulo the last
│ │ │ │ │  piece possibly being smaller). With pad files, the total size will be larger
│ │ │ │ │  than the sum of all (regular) file sizes.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__lleennggtthh(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │  int nnuumm__ppiieecceess () const;
│ │ │ │ │ +int ppiieeccee__lleennggtthh () const;
│ │ │ │ │  piece_length() and num_pieces() returns the number of byte for each piece and
│ │ │ │ │  the total number of pieces, respectively. The difference between piece_size()
│ │ │ │ │  and piece_length() is that piece_size() takes the piece index as argument and
│ │ │ │ │  gives you the exact size of that piece. It will always be the same as
│ │ │ │ │  piece_length() except in the case of the last piece, which may be smaller.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │  int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │  returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │  in the last piece)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │ -piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ +********** eenndd__ppiieeccee(()) llaasstt__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │  index_range ppiieeccee__rraannggee () const;
│ │ │ │ │  piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ +piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │  last_piece() returns the index to the last piece in the torrent and end_piece()
│ │ │ │ │  returns the index to the one-past-end piece in the torrent piece_range()
│ │ │ │ │  returns an implementation-defined type that can be used as the container in a
│ │ │ │ │  range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │ -info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ +********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │  sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ +info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │  returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │ │  info_hashes() to get an object that may hold both a v1 and v2 info-hash
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** vv11(()) vv22(()) **********
│ │ │ │ │ -bool vv11 () const;
│ │ │ │ │  bool vv22 () const;
│ │ │ │ │ +bool vv11 () const;
│ │ │ │ │  returns whether this torrent has v1 and/or v2 metadata, respectively. Hybrid
│ │ │ │ │  torrents have both. These are shortcuts for info_hashes().has_v1() and
│ │ │ │ │  info_hashes().has_v2() calls.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnuumm__ffiilleess(()) **********
│ │ │ │ │  int nnuumm__ffiilleess () const;
│ │ │ │ │  If you need index-access to files you can use the num_files() along with the
│ │ │ │ │ @@ -2896,48 +2896,48 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p"
│ │ │ │ │  class holding the info-hash of a torrent. It can hold a v1 info-hash (SHA-1) or
│ │ │ │ │  a v2 info-hash (SHA-256) or both.
│ │ │ │ │  Note
│ │ │ │ │  If has_v2() is false then the v1 hash might actually be a truncated v2 hash
│ │ │ │ │  struct info_hash_t
│ │ │ │ │  {
│ │ │ │ │ -   explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ -   iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │     iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │     explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ +   explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ +   iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ +   bool hhaass (protocol_version v) const;
│ │ │ │ │     bool hhaass__vv11 () const;
│ │ │ │ │     bool hhaass__vv22 () const;
│ │ │ │ │ -   bool hhaass (protocol_version v) const;
│ │ │ │ │     sha1_hash ggeett (protocol_version v) const;
│ │ │ │ │     sha1_hash ggeett__bbeesstt () const;
│ │ │ │ │     friend bool ooppeerraattoorr!!== (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │ │     friend bool ooppeerraattoorr==== (info_hash_t const& lhs, info_hash_t const& rhs)
│ │ │ │ │  noexcept;
│ │ │ │ │     template  void ffoorr__eeaacchh (F f) const;
│ │ │ │ │     bool ooppeerraattoorr<< (info_hash_t const& o) const;
│ │ │ │ │     friend std::ostream& ooppeerraattoorr<<<< (std::ostream& os, info_hash_t const& ih);
│ │ │ │ │  
│ │ │ │ │     sha1_hash v1;
│ │ │ │ │     sha256_hash v2;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iinnffoo__hhaasshh__tt(()) **********
│ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ -iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │  iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │  explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ +iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │  The default constructor creates an object that has neither a v1 or v2 hash.
│ │ │ │ │  For backwards compatibility, make it possible to construct directly from a v1
│ │ │ │ │  hash. This constructor allows iimmpplliicciitt conversion from a v1 hash, but the
│ │ │ │ │  implicitness is deprecated.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaass(()) hhaass__vv22(()) hhaass__vv11(()) **********
│ │ │ │ │ +********** hhaass__vv22(()) hhaass(()) hhaass__vv11(()) **********
│ │ │ │ │ +bool hhaass (protocol_version v) const;
│ │ │ │ │  bool hhaass__vv11 () const;
│ │ │ │ │  bool hhaass__vv22 () const;
│ │ │ │ │ -bool hhaass (protocol_version v) const;
│ │ │ │ │  returns true if the corresponding info hash is present in this object.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ggeett(()) **********
│ │ │ │ │  sha1_hash ggeett (protocol_version v) const;
│ │ │ │ │  returns the has for the specified protocol version
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ggeett__bbeesstt(()) **********
│ │ │ │ │ @@ -2951,16 +2951,16 @@
│ │ │ │ │  The signature of F is:
│ │ │ │ │  void(sha1_hash const&, protocol_version);
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ppiieeccee__bblloocckk ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_i_e_c_e___b_l_o_c_k_._h_p_p"
│ │ │ │ │  struct piece_block
│ │ │ │ │  {
│ │ │ │ │ -   ppiieeccee__bblloocckk (piece_index_t p_index, int b_index);
│ │ │ │ │     ppiieeccee__bblloocckk () = default;
│ │ │ │ │ +   ppiieeccee__bblloocckk (piece_index_t p_index, int b_index);
│ │ │ │ │     bool ooppeerraattoorr<< (piece_block const& b) const;
│ │ │ │ │     bool ooppeerraattoorr==== (piece_block const& b) const;
│ │ │ │ │     bool ooppeerraattoorr!!== (piece_block const& b) const;
│ │ │ │ │  
│ │ │ │ │     static const piece_block invalid;
│ │ │ │ │     piece_index_t piece_index {0};
│ │ │ │ │     int bblloocckk__iinnddeexx  = 0;
│ │ │ │ │ @@ -2991,39 +2991,39 @@
│ │ │ │ │        The byte offset within that piece where the range starts.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    length
│ │ │ │ │        The size of the range, in bytes.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ llooaadd__ttoorrrreenntt__ffiillee(()) llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_l_o_a_d___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ +   bdecode_node const& torrent_file);
│ │ │ │ │  add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │     span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ -   std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │  add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │     bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ │  add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │     std::string const& filename);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ +   std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │  add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │     span buffer);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ -   bdecode_node const& torrent_file);
│ │ │ │ │  These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │  object. The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ │  the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The
│ │ │ │ │  returned object is suitable to be:
│ │ │ │ │           * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │           * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │           * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ mmaakkee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │  std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp);
│ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │  std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │  Generates a magnet URI from the specified torrent.
│ │ │ │ │  Several fields from the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s objects are recorded in the magnet
│ │ │ │ │  link. In order to not include them, they have to be cleared before calling
│ │ │ │ │  _m_a_k_e___m_a_g_n_e_t___u_r_i_(_). These fields are used:
│ │ │ │ │       ti, info_hashes, url_seeds, dht_nodes, file_priorities, trackers,
│ │ │ │ │       name, peers.
│ │ │ │ │  Depending on what the use case for the resulting magnet link is, clearing peers
│ │ │ │ │ @@ -3038,17 +3038,17 @@
│ │ │ │ │  The overload that takes a _t_o_r_r_e_n_t___h_a_n_d_l_e will make blocking calls to query
│ │ │ │ │  information about the torrent. If the torrent handle is invalid, an empty
│ │ │ │ │  string is returned.
│ │ │ │ │  For more information about magnet links, see _m_a_g_n_e_t_ _l_i_n_k_s.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ppaarrssee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │ -add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec);
│ │ │ │ │ -add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri);
│ │ │ │ │  void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ │ +add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri);
│ │ │ │ │ +add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec);
│ │ │ │ │  This function parses out information from the magnet link and populates the
│ │ │ │ │  _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object. The overload that does not take an error_code
│ │ │ │ │  reference will throw a system_error on error The overload taking an
│ │ │ │ │  add_torrent_params reference will fill in the fields specified in the magnet
│ │ │ │ │  URI.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ttoorrrreenntt__ppeeeerr__eeqquuaall(()) ************
│ │ │ │ │ @@ -3578,28 +3578,28 @@
│ │ │ │ │  have its hook functions called on event specific to that peer.
│ │ │ │ │  The peer_connection_handle will be valid as long as the shared_ptr is being
│ │ │ │ │  held by the torrent object. So, it is generally a good idea to not keep a
│ │ │ │ │  shared_ptr to your own _p_e_e_r___p_l_u_g_i_n. If you want to keep references to it, use
│ │ │ │ │  weak_ptr.
│ │ │ │ │  If this function throws an exception, the connection will be closed.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │  virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │  virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │  These hooks are called when a piece passes the hash check or fails the hash
│ │ │ │ │  check, respectively. The index is the piece index that was downloaded. It is
│ │ │ │ │  possible to access the list of peers that participated in sending the piece
│ │ │ │ │  through the torrent and the piece_picker.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttiicckk(()) **********
│ │ │ │ │  virtual void ttiicckk ();
│ │ │ │ │  This hook is called approximately once per second. It is a way of making it
│ │ │ │ │  easy for plugins to do timed events, for sending messages or whatever.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__rreessuummee(()) oonn__ppaauussee(()) **********
│ │ │ │ │ +********** oonn__ppaauussee(()) oonn__rreessuummee(()) **********
│ │ │ │ │  virtual bool oonn__rreessuummee ();
│ │ │ │ │  virtual bool oonn__ppaauussee ();
│ │ │ │ │  These hooks are called when the torrent is paused and resumed respectively. The
│ │ │ │ │  return value indicates if the event was handled. A return value of true
│ │ │ │ │  indicates that it was handled, and no other _p_l_u_g_i_n after this one will have
│ │ │ │ │  this hook function called, and the standard handler will also not be invoked.
│ │ │ │ │  So, returning true effectively overrides the standard behavior of pause or
│ │ │ │ │ @@ -3647,43 +3647,43 @@
│ │ │ │ │  {
│ │ │ │ │     virtual string_view ttyyppee () const;
│ │ │ │ │     virtual void aadddd__hhaannddsshhaakkee (entry&);
│ │ │ │ │     virtual void oonn__ddiissccoonnnneecctt (error_code const&);
│ │ │ │ │     virtual void oonn__ccoonnnneecctteedd ();
│ │ │ │ │     virtual bool oonn__hhaannddsshhaakkee (span);
│ │ │ │ │     virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&);
│ │ │ │ │ -   virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │     virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ -   virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ -   virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │     virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ -   virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ +   virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │     virtual bool oonn__cchhookkee ();
│ │ │ │ │ +   virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +   virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │     virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ +   virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │     virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -   virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ -   virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │     virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │        , span //**bbuuff**//);
│ │ │ │ │     virtual bool oonn__rreejjeecctt (peer_request const&);
│ │ │ │ │ -   virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │     virtual bool oonn__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ +   virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ +   virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │     virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ +   virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │     virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │     virtual void sseenntt__cchhookkee ();
│ │ │ │ │ -   virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -   virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ -   virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │     virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ -   virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -   virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ -   virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │     virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -   virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │     virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +   virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │     virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │     virtual bool ccaann__ddiissccoonnnneecctt (error_code const& //**eecc**//);
│ │ │ │ │     virtual bool oonn__eexxtteennddeedd (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │        span //**bbooddyy**//);
│ │ │ │ │     virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │        span //**bbooddyy**//);
│ │ │ │ │     virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ @@ -3719,48 +3719,48 @@
│ │ │ │ │  ********** oonn__eexxtteennssiioonn__hhaannddsshhaakkee(()) **********
│ │ │ │ │  virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&);
│ │ │ │ │  called when the extension handshake from the other end is received if this
│ │ │ │ │  returns false, it means that this extension isn't supported by this peer. It
│ │ │ │ │  will result in this _p_e_e_r___p_l_u_g_i_n being removed from the peer_connection and
│ │ │ │ │  destructed. this is not called for web seeds
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__aallll(()) oonn__hhaavvee(()) oonn__bbiittffiieelldd(()) oonn__ddoonntt__hhaavvee(())
│ │ │ │ │ -oonn__hhaavvee__nnoonnee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__uunncchhookkee(()) oonn__cchhookkee(()) oonn__iinntteerreesstteedd(())
│ │ │ │ │ -oonn__rreeqquueesstt(()) **********
│ │ │ │ │ -virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +********** oonn__ddoonntt__hhaavvee(()) oonn__uunncchhookkee(()) oonn__bbiittffiieelldd(()) oonn__hhaavvee(()) oonn__hhaavvee__aallll(())
│ │ │ │ │ +oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__nnoonnee(()) oonn__cchhookkee(()) oonn__iinntteerreesstteedd(()) oonn__rreeqquueesstt(())
│ │ │ │ │ +oonn__aalllloowweedd__ffaasstt(()) **********
│ │ │ │ │  virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ -virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ -virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │  virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ +virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │  virtual bool oonn__cchhookkee ();
│ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │  virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │  virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ -virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │  returning true from any of the message handlers indicates that the _p_l_u_g_i_n has
│ │ │ │ │  handled the message. it will break the _p_l_u_g_i_n chain traversing and not let
│ │ │ │ │  anyone else handle the message, including the default handler.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** oonn__ppiieeccee(()) **********
│ │ │ │ │  virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │        , span //**bbuuff**//);
│ │ │ │ │  This function is called when the peer connection is receiving a piece. buf
│ │ │ │ │  points (non-owning pointer) to the data in an internal immutable disk buffer.
│ │ │ │ │  The length of the data is specified in the length member of the piece
│ │ │ │ │  parameter. returns true to indicate that the piece is handled and the rest of
│ │ │ │ │  the logic should be ignored.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseenntt__uunncchhookkee(()) sseenntt__hhaavvee(()) sseenntt__ppiieeccee(()) sseenntt__nnoott__iinntteerreesstteedd(())
│ │ │ │ │ +********** sseenntt__hhaavvee(()) sseenntt__uunncchhookkee(()) sseenntt__ppiieeccee(()) sseenntt__nnoott__iinntteerreesstteedd(())
│ │ │ │ │  sseenntt__iinntteerreesstteedd(()) **********
│ │ │ │ │ -virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ -virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │  virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │  virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ +virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ +virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │  called after a choke message has been sent to the peer
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseenntt__ppaayyllooaadd(()) **********
│ │ │ │ │  virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │  called after piece data has been sent to the peer this can be used for stats
│ │ │ │ │  book keeping
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -3783,15 +3783,15 @@
│ │ │ │ │  receiving large messages.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** oonn__uunnkknnoowwnn__mmeessssaaggee(()) **********
│ │ │ │ │  virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │        span //**bbooddyy**//);
│ │ │ │ │  this is not called for web seeds
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │  virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │  virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │  called when a piece that this peer participated in either fails or passes the
│ │ │ │ │  hash_check
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttiicckk(()) **********
│ │ │ │ │  virtual void ttiicckk ();
│ │ │ │ │ @@ -3803,16 +3803,16 @@
│ │ │ │ │  original request message won't be sent and no other _p_l_u_g_i_n will have this
│ │ │ │ │  function called.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ccrryyppttoo__pplluuggiinn ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_._h_p_p"
│ │ │ │ │  struct crypto_plugin
│ │ │ │ │  {
│ │ │ │ │ -   virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0;
│ │ │ │ │     virtual void sseett__oouuttggooiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ +   virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0;
│ │ │ │ │     eennccrryypptt (span> //**sseenndd__vveecc**//) = 0;
│ │ │ │ │     virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//
│ │ │ │ │  ) = 0;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ddeeccrryypptt(()) **********
│ │ │ │ │  virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//) =
│ │ │ │ │ @@ -3837,18 +3837,18 @@
│ │ │ │ │     connection_type ttyyppee () const;
│ │ │ │ │     void aadddd__eexxtteennssiioonn (std::shared_ptr);
│ │ │ │ │     peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const;
│ │ │ │ │     bool iiss__sseeeedd () const;
│ │ │ │ │     bool uuppllooaadd__oonnllyy () const;
│ │ │ │ │     peer_id const& ppiidd () const;
│ │ │ │ │     bool hhaass__ppiieeccee (piece_index_t i) const;
│ │ │ │ │ -   bool iiss__cchhookkeedd () const;
│ │ │ │ │     bool iiss__iinntteerreessttiinngg () const;
│ │ │ │ │ -   bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │ +   bool iiss__cchhookkeedd () const;
│ │ │ │ │     bool iiss__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │ +   bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │     void cchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │     void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │     void ggeett__ppeeeerr__iinnffoo (peer_info& p) const;
│ │ │ │ │     torrent_handle aassssoocciiaatteedd__ttoorrrreenntt () const;
│ │ │ │ │     _t_c_p_:_:_e_n_d_p_o_i_n_t const& rreemmoottee () const;
│ │ │ │ │     _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const;
│ │ │ │ │     bool iiss__oouuttggooiinngg () const;
│ │ │ │ │ @@ -3865,33 +3865,33 @@
│ │ │ │ │  (4,5);
│ │ │ │ │     bool ccaann__ddiissccoonnnneecctt (error_code const& ec) const;
│ │ │ │ │     bool hhaass__mmeettaaddaattaa () const;
│ │ │ │ │     bool iinn__hhaannddsshhaakkee () const;
│ │ │ │ │     void sseenndd__bbuuffffeerr (char const* begin, int size);
│ │ │ │ │     time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const;
│ │ │ │ │     std::time_t llaasstt__sseeeenn__ccoommpplleettee () const;
│ │ │ │ │ +   bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │     bool ooppeerraattoorr!!== (peer_connection_handle const& o) const;
│ │ │ │ │     bool ooppeerraattoorr==== (peer_connection_handle const& o) const;
│ │ │ │ │ -   bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │  The _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e provides a handle to the internal bittorrent peer
│ │ │ │ │  connection object to plugins. It's low level and may not be a stable API across
│ │ │ │ │  libtorrent versions.
│ │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ │  {
│ │ │ │ │     explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc);
│ │ │ │ │     bool ssuuppppoorrtt__eexxtteennssiioonnss () const;
│ │ │ │ │     bool ppaacckkeett__ffiinniisshheedd () const;
│ │ │ │ │     bool ssuuppppoorrttss__eennccrryyppttiioonn () const;
│ │ │ │ │ -   void sswwiittcchh__sseenndd__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │     void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ +   void sswwiittcchh__sseenndd__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ccrreeaattee__uutt__ppeexx__pplluuggiinn(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_/_u_t___p_e_x_._h_p_p"
│ │ │ │ │  std::shared_ptr ccrreeaattee__uutt__ppeexx__pplluuggiinn (torrent_handle const&,
│ │ │ │ │  client_data_t);
│ │ │ │ │ @@ -3952,73 +3952,73 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_f_i_l_e___s_t_o_r_a_g_e_._h_p_p"
│ │ │ │ │  The file_storage class represents a file list and the piece size. Everything
│ │ │ │ │  necessary to interpret a regular bittorrent storage file structure.
│ │ │ │ │  class file_storage
│ │ │ │ │  {
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │     void rreesseerrvvee (int num_files);
│ │ │ │ │ -   void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ -      , std::string const& path, std::int64_t file_size
│ │ │ │ │ -      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ -      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │ │     void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │     void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │  file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │     void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ +   void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ +      , std::string const& path, std::int64_t file_size
│ │ │ │ │ +      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ +      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │     std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │        , std::int64_t size) const;
│ │ │ │ │     peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │  const;
│ │ │ │ │     int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │     file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │     index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │     int nnuumm__ppiieecceess () const;
│ │ │ │ │     void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ -   int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ +   int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │     int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │     int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │     int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │     std::string const& nnaammee () const;
│ │ │ │ │     void sseett__nnaammee (std::string const& n);
│ │ │ │ │     void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │     void ccaannoonniiccaalliizzee ();
│ │ │ │ │ -   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -   std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ -"") const;
│ │ │ │ │ -   std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ +   string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │     sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +   bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +   std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │     sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │     std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -   std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -   string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +   std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ +   std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ +"") const;
│ │ │ │ │     std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ -   bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │     int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ -   index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │     int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ -   int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ +   index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ +   int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │     std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │  save_path) const;
│ │ │ │ │     void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │     file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │     bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │     file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │     file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ @@ -4041,33 +4041,33 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreesseerrvvee(()) **********
│ │ │ │ │  void rreesseerrvvee (int num_files);
│ │ │ │ │  allocates space for num_files in the internal file list. This can be used to
│ │ │ │ │  avoid reallocating the internal file list when the number of files to be added
│ │ │ │ │  is known up-front.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ffiillee(()) aadddd__ffiillee__bboorrrrooww(()) **********
│ │ │ │ │ -void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ -      , std::string const& path, std::int64_t file_size
│ │ │ │ │ -      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ -      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │ │ +********** aadddd__ffiillee__bboorrrrooww(()) aadddd__ffiillee(()) **********
│ │ │ │ │  void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │  void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │  void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ +void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ +      , std::string const& path, std::int64_t file_size
│ │ │ │ │ +      , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ +      , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │ │  Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │  filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │  memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │  stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │  it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │  byte binary SHA-1 hash of the file.
│ │ │ │ │  if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -4136,15 +4136,15 @@
│ │ │ │ │  range-for loop. Where the values are the indices of all files in the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │  std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │  returns the total number of bytes all the files in this torrent spans
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** nnuumm__ppiieecceess(()) sseett__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ +********** sseett__nnuumm__ppiieecceess(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │  int nnuumm__ppiieecceess () const;
│ │ │ │ │  void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │  set and get the number of pieces in the torrent
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eenndd__ppiieeccee(()) **********
│ │ │ │ │  piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │  returns the index of the one-past-end piece in the file storage
│ │ │ │ │ @@ -4157,17 +4157,17 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppiieeccee__rraannggee(()) **********
│ │ │ │ │  index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │  returns an implementation-defined type that can be used as the container in a
│ │ │ │ │  range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │  _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__lleennggtthh(()) sseett__ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │  void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ +int ppiieeccee__lleennggtthh () const;
│ │ │ │ │  set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │ │  and at least 16 kiB.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │  int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │  returns the piece size of index. This will be the same as _p_i_e_c_e___l_e_n_g_t_h_(_),
│ │ │ │ │  except for the last piece, which may be shorter.
│ │ │ │ │ @@ -4198,27 +4198,27 @@
│ │ │ │ │  void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │  swap all content of tthhiiss with ttii.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │  void ccaannoonniiccaalliizzee ();
│ │ │ │ │  arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshh(()) rroooott(()) mmttiimmee(()) ffiillee__ssiizzee(()) ffiillee__nnaammee(()) ffiillee__ppaatthh(()) ffiillee__ooffffsseett(())
│ │ │ │ │ -ssyymmlliinnkk(()) rroooott__ppttrr(()) ppaadd__ffiillee__aatt(()) **********
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ -const;
│ │ │ │ │ -std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ +********** ffiillee__nnaammee(()) hhaasshh(()) mmttiimmee(()) rroooott__ppttrr(()) ffiillee__ppaatthh(()) rroooott(()) ssyymmlliinnkk(())
│ │ │ │ │ +ffiillee__ssiizzee(()) ppaadd__ffiillee__aatt(()) ffiillee__ooffffsseett(()) **********
│ │ │ │ │ +string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │  sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │  sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │  std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ +std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ +const;
│ │ │ │ │  std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ -bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │  These functions are used to query attributes of files at a given index.
│ │ │ │ │  The hash() is a SHA-1 hash of the file, or 0 if none was provided in the
│ │ │ │ │  torrent file. This can potentially be used to join a bittorrent network with
│ │ │ │ │  other file sharing networks.
│ │ │ │ │  root() returns the SHA-256 merkle tree root of the specified file, in case this
│ │ │ │ │  is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │  SHA-256 merkle tree root hash for the specified file. The pointer points into
│ │ │ │ │ @@ -4231,26 +4231,26 @@
│ │ │ │ │  file_size() returns the size of a file.
│ │ │ │ │  pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │  file_name() returns jjuusstt the name of the file, whereas file_path() returns the
│ │ │ │ │  path (inside the torrent file) with the filename appended.
│ │ │ │ │  file_offset() returns the byte offset within the torrent file where this file
│ │ │ │ │  starts. It can be used to map the file to a piece index (given the piece size).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__nnuumm__bblloocckkss(()) ffiillee__nnuumm__ppiieecceess(()) ffiillee__ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +********** ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__bblloocckkss(()) ffiillee__nnuumm__ppiieecceess(()) **********
│ │ │ │ │  int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ -index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │  int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ +index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │  Returns the number of pieces or blocks the file atindexspans, under the
│ │ │ │ │  assumption that the file is aligned to the start of a piece. This is only
│ │ │ │ │  meaningful for v2 torrents, where files are guaranteed such alignment. These
│ │ │ │ │  numbers are used to size and navigate the merkle hash tree for each file.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) **********
│ │ │ │ │ -int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │  int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ +int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │  index of first piece node in the merkle tree
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__ppaatthh__hhaasshh(()) **********
│ │ │ │ │  std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path)
│ │ │ │ │  const;
│ │ │ │ │  returns the crc32 hash of file_path(index)
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -4267,15 +4267,15 @@
│ │ │ │ │  returns a bitmask of flags from file_flags_t that apply to file at index.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__aabbssoolluuttee__ppaatthh(()) **********
│ │ │ │ │  bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │  returns true if the file at the specified index has been renamed to have an
│ │ │ │ │  absolute path, i.e. is not anchored in the save path of the torrent.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__iinnddeexx__aatt__ppiieeccee(()) ffiillee__iinnddeexx__aatt__ooffffsseett(()) **********
│ │ │ │ │ +********** ffiillee__iinnddeexx__aatt__ooffffsseett(()) ffiillee__iinnddeexx__aatt__ppiieeccee(()) **********
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │  returns the index of the file at the given offset in the torrent
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__iinnddeexx__ffoorr__rroooott(()) **********
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │  finds the file with the given root hash and returns its index if there is no
│ │ │ │ │ @@ -4415,34 +4415,34 @@
│ │ │ │ │  passed in to libtorrent and returned on demand. It adds type-safety by
│ │ │ │ │  requiring the same type be requested out of it as was assigned to it.
│ │ │ │ │  struct client_data_t
│ │ │ │ │  {
│ │ │ │ │     cclliieenntt__ddaattaa__tt () = default;
│ │ │ │ │     explicit cclliieenntt__ddaattaa__tt (T* v);
│ │ │ │ │     client_data_t& ooppeerraattoorr== (T* v);
│ │ │ │ │ -   explicit operator TT () const;
│ │ │ │ │     T* ggeett () const;
│ │ │ │ │ -   operator void ccoonnsstt** () const = delete;
│ │ │ │ │ -   operator vvooiidd** () const = delete;
│ │ │ │ │ +   explicit operator TT () const;
│ │ │ │ │     client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │     client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │ +   operator vvooiidd** () const = delete;
│ │ │ │ │ +   operator void ccoonnsstt** () const = delete;
│ │ │ │ │  
│ │ │ │ │     template ::value>::type>
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclliieenntt__ddaattaa__tt(()) **********
│ │ │ │ │  cclliieenntt__ddaattaa__tt () = default;
│ │ │ │ │  construct a nullptr client data
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr==(()) ccoonnsstt**(()) vvooiidd**(()) **********
│ │ │ │ │ -operator void ccoonnsstt** () const = delete;
│ │ │ │ │ -operator vvooiidd** () const = delete;
│ │ │ │ │ +********** vvooiidd**(()) ooppeerraattoorr==(()) ccoonnsstt**(()) **********
│ │ │ │ │  client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │  client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │ +operator vvooiidd** () const = delete;
│ │ │ │ │ +operator void ccoonnsstt** () const = delete;
│ │ │ │ │  we don't allow type-unsafe operations
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ aadddd__ttoorrrreenntt__ppaarraammss ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │  The _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s contains all the information in a .torrent file along
│ │ │ │ │  with all information necessary to add that torrent to a _s_e_s_s_i_o_n. The key fields
│ │ │ │ │  when adding a torrent are:
│ │ │ │ │ @@ -4802,16 +4802,16 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ bblloocckk__iinnffoo ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │  holds the state of a block in a piece. Who we requested it from and how far
│ │ │ │ │  along we are at downloading it.
│ │ │ │ │  struct block_info
│ │ │ │ │  {
│ │ │ │ │ -   _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │     void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ +   _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  
│ │ │ │ │     enum block_state_t
│ │ │ │ │     {
│ │ │ │ │        none,
│ │ │ │ │        requested,
│ │ │ │ │        writing,
│ │ │ │ │        finished,
│ │ │ │ │ @@ -4820,16 +4820,16 @@
│ │ │ │ │     unsigned bytes_progress:15;
│ │ │ │ │     unsigned block_size:15;
│ │ │ │ │     unsigned state:2;
│ │ │ │ │     unsigned num_peers:14;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppeeeerr(()) sseett__ppeeeerr(()) **********
│ │ │ │ │ -_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ +_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  The peer is the ip address of the peer this block was downloaded from.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennuumm bblloocckk__ssttaattee__tt **********
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │   _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
│ │ │ │ │  |_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │  |none     |0    |This block has not been downloaded or requested form any   |
│ │ │ │ │ @@ -4925,112 +4925,112 @@
│ │ │ │ │  add_piece_flags_t flags = {}) const;
│ │ │ │ │     void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │     void rreeaadd__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │     bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │     void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │     void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ -   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │     void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │     std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │     void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │     void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -   void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │     void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +   void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │     void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ +   void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │     std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │  const;
│ │ │ │ │ -   void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │     void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │  file_progress_flags_t flags = {}) const;
│ │ │ │ │     std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │     void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ -   void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │     void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ -   void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │     std::vector ttrraacckkeerrss () const;
│ │ │ │ │ +   void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +   void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │     void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -   void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │     std::set uurrll__sseeeeddss () const;
│ │ │ │ │ +   void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │     void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │     std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │     void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │     void aadddd__eexxtteennssiioonn (
│ │ │ │ │        std::function(torrent_handle const&,
│ │ │ │ │  client_data_t)> const& ext
│ │ │ │ │        , client_data_t userdata = client_data_t{});
│ │ │ │ │     bool sseett__mmeettaaddaattaa (span metadata) const;
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │ -   void rreessuummee () const;
│ │ │ │ │     void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ -   torrent_flags_t ffllaaggss () const;
│ │ │ │ │ -   void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ +   void rreessuummee () const;
│ │ │ │ │     void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │     void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +   torrent_flags_t ffllaaggss () const;
│ │ │ │ │ +   void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │     void fflluusshh__ccaacchhee () const;
│ │ │ │ │     void ffoorrccee__rreecchheecckk () const;
│ │ │ │ │     void ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags = {}) const;
│ │ │ │ │ -   bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │     bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +   bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ -   queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ +   queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │ -   void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ -      , std::string const& private_key
│ │ │ │ │ -      , std::string const& dh_params);
│ │ │ │ │     void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │        , std::string const& private_key
│ │ │ │ │        , std::string const& dh_params
│ │ │ │ │        , std::string const& passphrase = "");
│ │ │ │ │ -   std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │ +   void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ +      , std::string const& private_key
│ │ │ │ │ +      , std::string const& dh_params);
│ │ │ │ │     std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ +   std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │     std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │     void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │     void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │     void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ -   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ -   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ -   void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │ -const;
│ │ │ │ │     void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │  const;
│ │ │ │ │ +   void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │ +const;
│ │ │ │ │ +   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │     void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │     std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ -   void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │     download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -   void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ -   void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ +   void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │     void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t =
│ │ │ │ │  {}) const;
│ │ │ │ │ +   void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ +   void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │     void ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ │     int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │     void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -   void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ +   void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     void ccoonnnneecctt__ppeeeerr (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ │     void cclleeaarr__ppeeeerrss ();
│ │ │ │ │     void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │     int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │     void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │     int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │     void mmoovvee__ssttoorraaggee (std::string const& save_path
│ │ │ │ │        , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ │        ) const;
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │ -   sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │     info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │ +   sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │     bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ -   bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │     bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ +   bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │     std::uint32_t iidd () const;
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │     client_data_t uusseerrddaattaa () const;
│ │ │ │ │     bool iinn__sseessssiioonn () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr add_piece_flags_t oovveerrwwrriittee__eexxiissttiinngg  = 0_bit;
│ │ │ │ │     static constexpr status_flags_t qquueerryy__ddiissttrriibbuutteedd__ccooppiieess  = 0_bit;
│ │ │ │ │ @@ -5109,17 +5109,17 @@
│ │ │ │ │  _p_e_e_r___i_n_f_o___a_l_e_r_t. The _a_l_e_r_t contain a list of _p_e_e_r___i_n_f_o objects, one for each
│ │ │ │ │  connected peer.
│ │ │ │ │  get_peer_info() is synchronous and takes a reference to a vector that will be
│ │ │ │ │  cleared and filled with one _e_n_t_r_y for each peer connected to this torrent,
│ │ │ │ │  given the handle is valid. Each _e_n_t_r_y in the vector contains information about
│ │ │ │ │  that particular peer. See _p_e_e_r___i_n_f_o.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ssttaattuuss(()) ssttaattuuss(()) **********
│ │ │ │ │ -torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +********** ssttaattuuss(()) ppoosstt__ssttaattuuss(()) **********
│ │ │ │ │  void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │  status() will return a structure with information about the status of this
│ │ │ │ │  torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e is invalid, it will throw system_error
│ │ │ │ │  exception. See _t_o_r_r_e_n_t___s_t_a_t_u_s. The flags argument filters what information is
│ │ │ │ │  returned in the _t_o_r_r_e_n_t___s_t_a_t_u_s. Some information in there is relatively
│ │ │ │ │  expensive to calculate, and if you're not interested in it (and see performance
│ │ │ │ │  issues), you can filter them out.
│ │ │ │ │  The status() function will block until the internal libtorrent thread responds
│ │ │ │ │ @@ -5138,17 +5138,17 @@
│ │ │ │ │  post_download_queue() triggers a download_queue_alert to be posted.
│ │ │ │ │  get_download_queue() is a synchronous call and returns a vector with
│ │ │ │ │  information about pieces that are partially downloaded or not downloaded but
│ │ │ │ │  partially requested. See _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o for the fields in the returned
│ │ │ │ │  vector.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │ -void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │  void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │  void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │  This function sets or resets the deadline associated with a specific piece
│ │ │ │ │  index (index). libtorrent will attempt to download this entire piece before the
│ │ │ │ │  deadline expires. This is not necessarily possible, but pieces with a more
│ │ │ │ │  recent deadline will always be prioritized over pieces with a deadline further
│ │ │ │ │  ahead in time. The deadline (and flags) of a piece can be changed by calling
│ │ │ │ │  this function again.
│ │ │ │ │ @@ -5157,18 +5157,18 @@
│ │ │ │ │  same effect as calling _r_e_a_d___p_i_e_c_e_(_) for index.
│ │ │ │ │  deadline is the number of milliseconds until this piece should be completed.
│ │ │ │ │  reset_piece_deadline removes the deadline from the piece. If it hasn't already
│ │ │ │ │  been downloaded, it will no longer be considered a priority.
│ │ │ │ │  clear_piece_deadlines() removes deadlines on all pieces in the torrent. As if
│ │ │ │ │  _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_) was called on all pieces.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__pprrooggrreessss(()) ppoosstt__ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ +********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ +void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │  std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │  const;
│ │ │ │ │ -void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │  void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │  This function fills in the supplied vector, or returns a vector, with the
│ │ │ │ │  number of bytes downloaded of each file in this torrent. The progress values
│ │ │ │ │  are ordered the same as the files in the _t_o_r_r_e_n_t___i_n_f_o.
│ │ │ │ │  This operation is not very cheap. Its complexity is OO((nn ++ mmjj)). Where nn is the
│ │ │ │ │  number of files, mm is the number of currently downloading pieces and jj is the
│ │ │ │ │ @@ -5191,19 +5191,19 @@
│ │ │ │ │  See _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__eerrrroorr(()) **********
│ │ │ │ │  void cclleeaarr__eerrrroorr () const;
│ │ │ │ │  If the torrent is in an error state (i.e. torrent_status::error is non-empty),
│ │ │ │ │  this will clear the error and start the torrent again.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ -void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ +********** aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) **********
│ │ │ │ │  void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ -void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │  std::vector ttrraacckkeerrss () const;
│ │ │ │ │ +void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │  trackers() returns the list of trackers for this torrent. The announce _e_n_t_r_y
│ │ │ │ │  contains both a string url which specify the announce url for the tracker as
│ │ │ │ │  well as an _i_n_t tier, which is specifies the order in which this tracker is
│ │ │ │ │  tried. If you want libtorrent to use another list of trackers for this torrent,
│ │ │ │ │  you can use replace_trackers() which takes a list of the same form as the one
│ │ │ │ │  returned from trackers() and will replace it. If you want an immediate effect,
│ │ │ │ │  you have to call _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_). See _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ @@ -5214,16 +5214,16 @@
│ │ │ │ │  insert it in the tier specified in the _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │  The updated set of trackers will be saved in the resume data, and when a
│ │ │ │ │  torrent is started with resume data, the trackers from the resume data will
│ │ │ │ │  replace the original ones.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__uurrll__sseeeedd(()) rreemmoovvee__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) **********
│ │ │ │ │  void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │  std::set uurrll__sseeeeddss () const;
│ │ │ │ │ +void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │  add_url_seed() adds another url to the torrent's list of url seeds. If the
│ │ │ │ │  given url already exists in that list, the call has no effect. The torrent will
│ │ │ │ │  connect to the server and try to download pieces from it, unless it's paused,
│ │ │ │ │  queued, checking or seeding. remove_url_seed() removes the given url if it
│ │ │ │ │  exists already. url_seeds() return a set of the url seeds currently in this
│ │ │ │ │  torrent. Note that URLs that fails may be removed automatically from the list.
│ │ │ │ │  See _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │ @@ -5267,35 +5267,35 @@
│ │ │ │ │  Clients should only use _i_s___v_a_l_i_d_(_) to determine if the result of session::
│ │ │ │ │  find_torrent() was successful.
│ │ │ │ │  Unlike other member functions which return a value, _i_s___v_a_l_i_d_(_) completes
│ │ │ │ │  immediately, without blocking on a result from the network thread. Also unlike
│ │ │ │ │  other functions, it never throws the system_error exception.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │ -void rreessuummee () const;
│ │ │ │ │  void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ +void rreessuummee () const;
│ │ │ │ │  pause(), and resume() will disconnect all peers and reconnect all peers
│ │ │ │ │  respectively. When a torrent is paused, it will however remember all share
│ │ │ │ │  ratios to all peers and remember all potential (not connected) peers. Torrents
│ │ │ │ │  may be paused automatically if there is a file error (e.g. disk full) or
│ │ │ │ │  something similar. See _f_i_l_e___e_r_r_o_r___a_l_e_r_t.
│ │ │ │ │  For possible values of the flags parameter, see pause_flags_t.
│ │ │ │ │  To know if a torrent is paused or not, call torrent_handle::flags() and check
│ │ │ │ │  for the torrent_status::paused flag.
│ │ │ │ │  Note
│ │ │ │ │  Torrents that are auto-managed may be automatically resumed again. It does not
│ │ │ │ │  make sense to pause an auto-managed torrent without making it not auto-managed
│ │ │ │ │  first. Torrents are auto-managed by default when added to the _s_e_s_s_i_o_n. For more
│ │ │ │ │  information, see _q_u_e_u_i_n_g.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffllaaggss(()) uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) **********
│ │ │ │ │ -torrent_flags_t ffllaaggss () const;
│ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ +********** sseett__ffllaaggss(()) ffllaaggss(()) uunnsseett__ffllaaggss(()) **********
│ │ │ │ │  void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │  void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +torrent_flags_t ffllaaggss () const;
│ │ │ │ │ +void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │  sets and gets the torrent state flags. See _t_o_r_r_e_n_t___f_l_a_g_s___t. The set_flags
│ │ │ │ │  overload that take a mask will affect all flags part of the mask, and set their
│ │ │ │ │  values to what the flags argument is set to. This allows clearing and setting
│ │ │ │ │  flags in a single function call. The set_flags overload that just takes flags,
│ │ │ │ │  sets all the specified flags and leave any other flags unchanged. unset_flags
│ │ │ │ │  clears the specified flags, while leaving any other flags unchanged.
│ │ │ │ │  Theseed_modeflag is special, it can only be cleared once the torrent has been
│ │ │ │ │ @@ -5405,35 +5405,35 @@
│ │ │ │ │  Note how outstanding_resume_data is a global counter in this example. This is
│ │ │ │ │  deliberate, otherwise there is a race condition for torrents that was just
│ │ │ │ │  asked to save their resume data, they posted the _a_l_e_r_t, but it has not been
│ │ │ │ │  received yet. Those torrents would report that they don't need to save resume
│ │ │ │ │  data again, and skipped by the initial loop, and thwart the counter otherwise.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nneeeedd__ssaavvee__rreessuummee__ddaattaa(()) **********
│ │ │ │ │ -bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │  bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ +bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │  This function returns true if anything that is stored in the resume data has
│ │ │ │ │  changed since the last time resume data was saved. The overload that takes
│ │ │ │ │  flags let you ask if specific categories of properties have changed. These
│ │ │ │ │  flags have the same behavior as in the _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) call.
│ │ │ │ │  This is a bblloocckkiinngg call. It will wait for a response from libtorrent's main
│ │ │ │ │  thread. A way to avoid blocking is to instead call _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) directly,
│ │ │ │ │  specifying the conditions under which resume data should be saved.
│ │ │ │ │  Note
│ │ │ │ │  A torrent's resume data is considered saved as soon as the
│ │ │ │ │  _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t is posted. It is important to make sure this _a_l_e_r_t is
│ │ │ │ │  received and handled in order for this function to be meaningful.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__uupp(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) **********
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__ttoopp(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__uupp(()) **********
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ -queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ +queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │  Every torrent that is added is assigned a queue position exactly one greater
│ │ │ │ │  than the greatest queue position of all existing torrents. Torrents that are
│ │ │ │ │  being seeded have -1 as their queue position, since they're no longer in line
│ │ │ │ │  to be downloaded.
│ │ │ │ │  When a torrent is removed or turns into a seed, all torrents with greater queue
│ │ │ │ │  positions have their positions decreased to fill in the space in the sequence.
│ │ │ │ │  queue_position() returns the torrent's position in the download queue. The
│ │ │ │ │ @@ -5448,21 +5448,21 @@
│ │ │ │ │  ********** qquueeuuee__ppoossiittiioonn__sseett(()) **********
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │  updates the position in the queue for this torrent. The relative order of all
│ │ │ │ │  other torrents remain intact but their numerical queue position shifts to make
│ │ │ │ │  space for this torrent's new position
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr(()) sseett__ssssll__cceerrttiiffiiccaattee(()) **********
│ │ │ │ │ -void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ -      , std::string const& private_key
│ │ │ │ │ -      , std::string const& dh_params);
│ │ │ │ │  void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │        , std::string const& private_key
│ │ │ │ │        , std::string const& dh_params
│ │ │ │ │        , std::string const& passphrase = "");
│ │ │ │ │ +void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ +      , std::string const& private_key
│ │ │ │ │ +      , std::string const& dh_params);
│ │ │ │ │  For SSL torrents, use this to specify a path to a .pem file to use as this
│ │ │ │ │  client's certificate. The certificate must be signed by the certificate in the
│ │ │ │ │  .torrent file to be valid.
│ │ │ │ │  The _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_) overload takes the actual certificate, private
│ │ │ │ │  key and DH params as strings, rather than paths to files.
│ │ │ │ │  cert is a path to the (signed) certificate in .pem format corresponding to this
│ │ │ │ │  torrent.
│ │ │ │ │ @@ -5477,16 +5477,16 @@
│ │ │ │ │  suspend connecting to any peers until it has one. It's typically desirable to
│ │ │ │ │  resume the torrent after setting the SSL certificate.
│ │ │ │ │  If you receive a _t_o_r_r_e_n_t___n_e_e_d___c_e_r_t___a_l_e_r_t, you need to call this to provide a
│ │ │ │ │  valid cert. If you don't have a cert you won't be allowed to connect to any
│ │ │ │ │  peers.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoorrrreenntt__ffiillee(()) ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) **********
│ │ │ │ │ -std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │  std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ +std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │  _t_o_r_r_e_n_t___f_i_l_e_(_) returns a pointer to the _t_o_r_r_e_n_t___i_n_f_o object associated with
│ │ │ │ │  this torrent. The _t_o_r_r_e_n_t___i_n_f_o object may be a copy of the internal object. If
│ │ │ │ │  the torrent doesn't have metadata, the pointer will not be initialized (i.e. a
│ │ │ │ │  nullptr). The torrent may be in a state without metadata only if it was started
│ │ │ │ │  without a .torrent file, e.g. by being added by magnet link.
│ │ │ │ │  Note that the _t_o_r_r_e_n_t___i_n_f_o object returned here may be a different instance
│ │ │ │ │  than the one added to the _s_e_s_s_i_o_n, with different attributes like piece layers,
│ │ │ │ │ @@ -5524,21 +5524,21 @@
│ │ │ │ │  uses in order to prefer picking rare pieces.
│ │ │ │ │  post_piece_availability() will trigger a _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y___a_l_e_r_t to be posted.
│ │ │ │ │  piece_availability() fills the specified std::vector with the availability
│ │ │ │ │  for each piece in this torrent. libtorrent does not keep track of availability
│ │ │ │ │  for seeds, so if the torrent is seeding the availability for all pieces is
│ │ │ │ │  reported as 0.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__ppiieeccee__pprriioorriittiieess(()) ppiieeccee__pprriioorriittyy(()) pprriioorriittiizzee__ppiieecceess(()) **********
│ │ │ │ │ +********** ggeett__ppiieeccee__pprriioorriittiieess(()) pprriioorriittiizzee__ppiieecceess(()) ppiieeccee__pprriioorriittyy(()) **********
│ │ │ │ │  void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │  std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │  download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ -void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │ -void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │  These functions are used to set and get the priority of individual pieces. By
│ │ │ │ │  default all pieces have priority 4. That means that the random rarest first
│ │ │ │ │  algorithm is effectively active for all pieces. You may however change the
│ │ │ │ │  priority of individual pieces. There are 8 priority levels. 0 means not to
│ │ │ │ │  download the piece at all. Otherwise, lower priority values means less likely
│ │ │ │ │  to be picked. Piece priority takes precedence over piece availability. Every
│ │ │ │ │  piece with priority 7 will be attempted to be picked before a priority 6 piece
│ │ │ │ │ @@ -5558,19 +5558,19 @@
│ │ │ │ │  where the piece index or priority is out of range, are not allowed.
│ │ │ │ │  get_piece_priorities returns a vector with one element for each piece in the
│ │ │ │ │  torrent. Each element is the current priority of that piece.
│ │ │ │ │  It's possible to cancel the effect of ffiillee priorities by setting the priorities
│ │ │ │ │  for the affected pieces. Care has to be taken when mixing usage of file- and
│ │ │ │ │  piece priorities.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) pprriioorriittiizzee__ffiilleess(()) **********
│ │ │ │ │ +********** ffiillee__pprriioorriittyy(()) pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │  void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │  std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ -void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │  download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ +void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │  index must be in the range [0, number_of_files).
│ │ │ │ │  file_priority() queries or sets the priority of file index.
│ │ │ │ │  prioritize_files() takes a vector that has at as many elements as there are
│ │ │ │ │  files in the torrent. Each _e_n_t_r_y is the priority of that file. The function
│ │ │ │ │  sets the priorities of all the pieces in the torrent based on the vector.
│ │ │ │ │  get_file_priorities() returns a vector with the priorities of all files.
│ │ │ │ │  The priority values are the same as for _p_i_e_c_e___p_r_i_o_r_i_t_y_(_). See
│ │ │ │ │ @@ -5589,19 +5589,19 @@
│ │ │ │ │  When combining file- and piece priorities, the resume file will record both.
│ │ │ │ │  When loading the resume data, the file priorities will be applied first, then
│ │ │ │ │  the piece priorities.
│ │ │ │ │  Moving data from a file into the part file is currently not supported. If a
│ │ │ │ │  file has its priority set to 0 aafftteerr it has already been created, it will not
│ │ │ │ │  be moved into the partfile.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) **********
│ │ │ │ │ -void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ -void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ +********** ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) **********
│ │ │ │ │  void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = {})
│ │ │ │ │  const;
│ │ │ │ │ +void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ +void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │  force_reannounce() will force this torrent to do another tracker request, to
│ │ │ │ │  receive new peers. The seconds argument specifies how many seconds from now to
│ │ │ │ │  issue the tracker announces.
│ │ │ │ │  If the tracker's min_interval has not passed since the last announce, the
│ │ │ │ │  forced announce will be scheduled to happen immediately as the min_interval
│ │ │ │ │  expires. This is to honor trackers minimum re-announce interval settings.
│ │ │ │ │  The tracker_index argument specifies which tracker to re-announce. If set to -
│ │ │ │ │ @@ -5619,20 +5619,20 @@
│ │ │ │ │  A scrape request queries the tracker for statistics such as total number of
│ │ │ │ │  incomplete peers, complete peers, number of downloads etc.
│ │ │ │ │  This request will specifically update the num_complete and num_incomplete
│ │ │ │ │  fields in the _t_o_r_r_e_n_t___s_t_a_t_u_s struct once it completes. When it completes, it
│ │ │ │ │  will generate a _s_c_r_a_p_e___r_e_p_l_y___a_l_e_r_t. If it fails, it will generate a
│ │ │ │ │  _s_c_r_a_p_e___f_a_i_l_e_d___a_l_e_r_t.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** uuppllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(())
│ │ │ │ │ +********** ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(())
│ │ │ │ │  **********
│ │ │ │ │  int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │  void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ +void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  set_upload_limit will limit the upload bandwidth used by this particular
│ │ │ │ │  torrent to the limit you set. It is given as the number of bytes per second the
│ │ │ │ │  torrent is allowed to upload. set_download_limit works the same way but for
│ │ │ │ │  download bandwidth instead of upload bandwidth. Note that setting a higher
│ │ │ │ │  limit on a torrent then the global limit (settings_pack::upload_rate_limit)
│ │ │ │ │  will not override the global rate limit. The torrent can never upload more than
│ │ │ │ │  the global rate limit.
│ │ │ │ │ @@ -5664,15 +5664,15 @@
│ │ │ │ │  int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │  set_max_uploads() sets the maximum number of peers that's unchoked at the same
│ │ │ │ │  time on this torrent. If you set this to -1, there will be no limit. This
│ │ │ │ │  defaults to infinite. The primary setting controlling this is the global
│ │ │ │ │  unchoke slots limit, set by unchoke_slots_limit in _s_e_t_t_i_n_g_s___p_a_c_k.
│ │ │ │ │  max_uploads() returns the current settings.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** mmaaxx__ccoonnnneeccttiioonnss(()) sseett__mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │ +********** sseett__mmaaxx__ccoonnnneeccttiioonnss(()) mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │  void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │  int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │  set_max_connections() sets the maximum number of connection this torrent will
│ │ │ │ │  open. If all connections are used up, incoming connections may be refused or
│ │ │ │ │  poor connections may be closed. This must be at least 2. The default is
│ │ │ │ │  unlimited number of connections. If -1 is given to the function, it means
│ │ │ │ │  unlimited. There is also a global limit of the number of connections, set by
│ │ │ │ │ @@ -5724,27 +5724,27 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreennaammee__ffiillee(()) **********
│ │ │ │ │  void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │  Renames the file with the given index asynchronously. The rename operation is
│ │ │ │ │  complete when either a _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t or _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t is
│ │ │ │ │  posted.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │ -sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │ +********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │  info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │ +sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │  returns the info-hash(es) of the torrent. If this handle is to a torrent that
│ │ │ │ │  hasn't loaded yet (for instance by being added) by a URL, the returned value is
│ │ │ │ │  undefined. The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │ │  truncated hash for v2 torrents. For the full v2 info-hash, use info_hashes()
│ │ │ │ │  instead.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr====(()) ooppeerraattoorr!!==(()) ooppeerraattoorr<<(()) **********
│ │ │ │ │ +********** ooppeerraattoorr====(()) ooppeerraattoorr<<(()) ooppeerraattoorr!!==(()) **********
│ │ │ │ │  bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ -bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │  bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ +bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │  comparison operators. The order of the torrents is unspecified but stable.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iidd(()) **********
│ │ │ │ │  std::uint32_t iidd () const;
│ │ │ │ │  returns a unique identifier for this torrent. It's not a dense index. It's not
│ │ │ │ │  preserved across sessions.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -6204,17 +6204,17 @@
│ │ │ │ │  a unique, owning, reference to the storage of a torrent in a disk io subsystem
│ │ │ │ │  (class that implements _d_i_s_k___i_n_t_e_r_f_a_c_e). This is held by the internal libtorrent
│ │ │ │ │  torrent object to tie the storage object allocated for a torrent to the
│ │ │ │ │  lifetime of the internal torrent object. When a torrent is removed from the
│ │ │ │ │  _s_e_s_s_i_o_n, this holder is destructed and will inform the disk object.
│ │ │ │ │  struct storage_holder
│ │ │ │ │  {
│ │ │ │ │ -   ~~ssttoorraaggee__hhoollddeerr ();
│ │ │ │ │     ssttoorraaggee__hhoollddeerr () = default;
│ │ │ │ │     ssttoorraaggee__hhoollddeerr (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ │ +   ~~ssttoorraaggee__hhoollddeerr ();
│ │ │ │ │     explicit operator bbooooll () const;
│ │ │ │ │     operator ssttoorraaggee__iinnddeexx__tt () const;
│ │ │ │ │     void rreesseett ();
│ │ │ │ │     storage_holder& ooppeerraattoorr== (storage_holder const&) = delete;
│ │ │ │ │     ssttoorraaggee__hhoollddeerr (storage_holder const&) = delete;
│ │ │ │ │     ssttoorraaggee__hhoollddeerr (storage_holder&& rhs) noexcept;
│ │ │ │ │     storage_holder& ooppeerraattoorr== (storage_holder&& rhs) noexcept;
│ │ │ │ │ @@ -6304,20 +6304,20 @@
│ │ │ │ │  ************ sseettttiinnggss__iinntteerrffaaccee ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │  the common interface to _s_e_t_t_i_n_g_s___p_a_c_k and the internal representation of
│ │ │ │ │  settings.
│ │ │ │ │  struct settings_interface
│ │ │ │ │  {
│ │ │ │ │     virtual bool hhaass__vvaall (int name) const = 0;
│ │ │ │ │ -   virtual void sseett__ssttrr (int name, std::string val) = 0;
│ │ │ │ │     virtual void sseett__iinntt (int name, int val) = 0;
│ │ │ │ │ +   virtual void sseett__ssttrr (int name, std::string val) = 0;
│ │ │ │ │     virtual void sseett__bbooooll (int name, bool val) = 0;
│ │ │ │ │     virtual bool ggeett__bbooooll (int name) const = 0;
│ │ │ │ │ -   virtual std::string const& ggeett__ssttrr (int name) const = 0;
│ │ │ │ │     virtual int ggeett__iinntt (int name) const = 0;
│ │ │ │ │ +   virtual std::string const& ggeett__ssttrr (int name) const = 0;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ffiillee__ooppeenn__mmooddee__tt ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___i_n_t_e_r_f_a_c_e_._h_p_p"
│ │ │ │ │    read_only
│ │ │ │ │        open the file for reading only
│ │ │ │ │    write_only
│ │ │ │ │ @@ -7233,15 +7233,15 @@
│ │ │ │ │     char const* ssttoorraaggee__ppaatthh () const;
│ │ │ │ │     char const* oolldd__ppaatthh () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy  = alert_category::
│ │ │ │ │  storage;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssttoorraaggee__ppaatthh(()) oolldd__ppaatthh(()) **********
│ │ │ │ │ +********** oolldd__ppaatthh(()) ssttoorraaggee__ppaatthh(()) **********
│ │ │ │ │  char const* ssttoorraaggee__ppaatthh () const;
│ │ │ │ │  char const* oolldd__ppaatthh () const;
│ │ │ │ │  the path the torrent was moved to and from, respectively.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ssttoorraaggee__mmoovveedd__ffaaiilleedd__aalleerrtt ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p"
│ │ │ │ │  The storage_moved_failed_alert is generated when an attempt to move the
│ │ │ │ │ @@ -8479,24 +8479,24 @@
│ │ │ │ │  ************ ddhhtt__lliivvee__nnooddeess__aalleerrtt ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p"
│ │ │ │ │  posted in response to a call to session::dht_live_nodes(). It contains the live
│ │ │ │ │  nodes from the DHT routing table of one of the DHT nodes running locally.
│ │ │ │ │  struct dht_live_nodes_alert final : alert
│ │ │ │ │  {
│ │ │ │ │     std::string mmeessssaaggee () const override;
│ │ │ │ │ -   int nnuumm__nnooddeess () const;
│ │ │ │ │     std::vector> nnooddeess () const;
│ │ │ │ │ +   int nnuumm__nnooddeess () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy  = alert_category::dht;
│ │ │ │ │     sha1_hash node_id;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnuumm__nnooddeess(()) nnooddeess(()) **********
│ │ │ │ │ -int nnuumm__nnooddeess () const;
│ │ │ │ │  std::vector> nnooddeess () const;
│ │ │ │ │ +int nnuumm__nnooddeess () const;
│ │ │ │ │  the number of nodes in the routing table and the actual nodes.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    node_id
│ │ │ │ │        the local DHT node's node-ID this routing table belongs to
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ sseessssiioonn__ssttaattss__hheeaaddeerr__aalleerrtt ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p"
│ │ │ │ │ @@ -8530,15 +8530,15 @@
│ │ │ │ │  dht_operation;
│ │ │ │ │     sha1_hash node_id;
│ │ │ │ │     aux::noexcept_movable endpoint;
│ │ │ │ │     time_duration const interval;
│ │ │ │ │     int const num_infohashes;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssaammpplleess(()) nnuumm__ssaammpplleess(()) **********
│ │ │ │ │ +********** nnuumm__ssaammpplleess(()) ssaammpplleess(()) **********
│ │ │ │ │  std::vector ssaammpplleess () const;
│ │ │ │ │  int nnuumm__ssaammpplleess () const;
│ │ │ │ │  returns the number of info-hashes returned by the node, as well as the actual
│ │ │ │ │  info-hashes. num_samples() is more efficient than samples().size().
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnuumm__nnooddeess(()) **********
│ │ │ │ │  int nnuumm__nnooddeess () const;
│ │ │ │ │ @@ -8765,16 +8765,16 @@
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    trackers
│ │ │ │ │        list of trackers and their status for the torrent
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ aalleerrtt__ccaasstt(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t_._h_p_p"
│ │ │ │ │ -template  T const* aalleerrtt__ccaasstt (alert const* a);
│ │ │ │ │  template  T* aalleerrtt__ccaasstt (alert* a);
│ │ │ │ │ +template  T const* aalleerrtt__ccaasstt (alert const* a);
│ │ │ │ │  When you get an _a_l_e_r_t, you can use alert_cast<> to attempt to cast the pointer
│ │ │ │ │  to a specific _a_l_e_r_t type, in order to query it for more information.
│ │ │ │ │  Note
│ │ │ │ │  alert_cast<> can only cast to an exact _a_l_e_r_t type, not a base class
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ooppeerraattiioonn__nnaammee(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_o_p_e_r_a_t_i_o_n_s_._h_p_p"
│ │ │ │ │ @@ -8930,25 +8930,25 @@
│ │ │ │ │        this constant represents "max_alert_index" + 1
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ccoouunntteerrss ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_r_f_o_r_m_a_n_c_e___c_o_u_n_t_e_r_s_._h_p_p"
│ │ │ │ │  struct counters
│ │ │ │ │  {
│ │ │ │ │     ccoouunntteerrss () ;
│ │ │ │ │ -   counters& ooppeerraattoorr== (counters const&) & ;
│ │ │ │ │     ccoouunntteerrss (counters const&) ;
│ │ │ │ │ -   std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ +   counters& ooppeerraattoorr== (counters const&) & ;
│ │ │ │ │     std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │ -   void sseett__vvaalluuee (int c, std::int64_t value) ;
│ │ │ │ │ +   std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │     void bblleenndd__ssttaattss__ccoouunntteerr (int c, std::int64_t value, int ratio) ;
│ │ │ │ │ +   void sseett__vvaalluuee (int c, std::int64_t value) ;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr[[]](()) iinncc__ssttaattss__ccoouunntteerr(()) **********
│ │ │ │ │ -std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ +********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │  std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │ +std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │  returns the new value
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ssttaattss__mmeettrriicc ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___s_t_a_t_s_._h_p_p"
│ │ │ │ │  describes one statistics metric from the _s_e_s_s_i_o_n. For more information, see the
│ │ │ │ │  _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │  struct stats_metric
│ │ │ │ │ @@ -8995,18 +8995,18 @@
│ │ │ │ │  addresses as allowed or disallowed. The default constructor creates a single
│ │ │ │ │  rule that allows all addresses (0.0.0.0 - 255.255.255.255 for the IPv4 range,
│ │ │ │ │  and the equivalent range covering all addresses for the IPv6 range).
│ │ │ │ │  A default constructed _i_p___f_i_l_t_e_r does not filter any address.
│ │ │ │ │  struct ip_filter
│ │ │ │ │  {
│ │ │ │ │     iipp__ffiilltteerr ();
│ │ │ │ │ -   ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ +   ~~iipp__ffiilltteerr ();
│ │ │ │ │     iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │     iipp__ffiilltteerr (ip_filter const&);
│ │ │ │ │ -   ~~iipp__ffiilltteerr ();
│ │ │ │ │ +   ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │     bool eemmppttyy () const;
│ │ │ │ │     void aadddd__rruullee (address const& first, address const& last, std::uint32_t
│ │ │ │ │  flags);
│ │ │ │ │     std::uint32_t aacccceessss (address const& addr) const;
│ │ │ │ │     filter_tuple_t eexxppoorrtt__ffiilltteerr () const;
│ │ │ │ │  
│ │ │ │ │ @@ -9057,19 +9057,19 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_p___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │  the port filter maps non-overlapping port ranges to flags. This is primarily
│ │ │ │ │  used to indicate whether a range of ports should be connected to or not. The
│ │ │ │ │  default is to have the full port range (0-65535) set to flag 0.
│ │ │ │ │  class port_filter
│ │ │ │ │  {
│ │ │ │ │     ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │ -   port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ -   ppoorrtt__ffiilltteerr ();
│ │ │ │ │     ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ -   port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ +   ppoorrtt__ffiilltteerr ();
│ │ │ │ │     ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │ +   port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ +   port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │     void aadddd__rruullee (std::uint16_t first, std::uint16_t last, std::uint32_t
│ │ │ │ │  flags);
│ │ │ │ │     std::uint32_t aacccceessss (std::uint16_t port) const;
│ │ │ │ │  
│ │ │ │ │     enum access_flags
│ │ │ │ │     {
│ │ │ │ │        blocked,
│ │ │ │ │ @@ -9111,46 +9111,46 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_n_t_r_y_._h_p_p"
│ │ │ │ │  The entry class represents one node in a bencoded hierarchy. It works as a
│ │ │ │ │  variant type, it can be either a list, a dictionary (std::map), an integer or a
│ │ │ │ │  string.
│ │ │ │ │  class entry
│ │ │ │ │  {
│ │ │ │ │     data_type ttyyppee () const;
│ │ │ │ │ -   eennttrryy (integer_type);
│ │ │ │ │ +   eennttrryy (dictionary_type);
│ │ │ │ │     eennttrryy (preformatted_type);
│ │ │ │ │     eennttrryy (list_type);
│ │ │ │ │     eennttrryy (span);
│ │ │ │ │ -   eennttrryy (dictionary_type);
│ │ │ │ │ +   eennttrryy (integer_type);
│ │ │ │ │     eennttrryy (U v);
│ │ │ │ │     eennttrryy (data_type t);
│ │ │ │ │     eennttrryy (bdecode_node const& n);
│ │ │ │ │     entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │ -   entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │     entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │     entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ -   entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │     entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ -   entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ -   entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │     entry& ooppeerraattoorr== (U v) &;
│ │ │ │ │     integer_type& iinntteeggeerr ();
│ │ │ │ │ +   preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │ +   integer_type const& iinntteeggeerr () const;
│ │ │ │ │     list_type& lliisstt ();
│ │ │ │ │ +   string_type& ssttrriinngg ();
│ │ │ │ │ +   preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │     list_type const& lliisstt () const;
│ │ │ │ │     string_type const& ssttrriinngg () const;
│ │ │ │ │ -   dictionary_type const& ddiicctt () const;
│ │ │ │ │ -   preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │     dictionary_type& ddiicctt ();
│ │ │ │ │ -   preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ -   integer_type const& iinntteeggeerr () const;
│ │ │ │ │ -   string_type& ssttrriinngg ();
│ │ │ │ │ +   dictionary_type const& ddiicctt () const;
│ │ │ │ │     void sswwaapp (entry& e);
│ │ │ │ │     entry& ooppeerraattoorr[[]] (string_view key);
│ │ │ │ │     entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │ -   entry* ffiinndd__kkeeyy (string_view key);
│ │ │ │ │     entry const* ffiinndd__kkeeyy (string_view key) const;
│ │ │ │ │ +   entry* ffiinndd__kkeeyy (string_view key);
│ │ │ │ │     std::string ttoo__ssttrriinngg (bool single_line = false) const;
│ │ │ │ │  
│ │ │ │ │     enum data_type
│ │ │ │ │     {
│ │ │ │ │        int_t,
│ │ │ │ │        string_t,
│ │ │ │ │        list_t,
│ │ │ │ │ @@ -9161,52 +9161,52 @@
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttyyppee(()) **********
│ │ │ │ │  data_type ttyyppee () const;
│ │ │ │ │  returns the concrete type of the _e_n_t_r_y
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennttrryy(()) **********
│ │ │ │ │ -eennttrryy (integer_type);
│ │ │ │ │ +eennttrryy (dictionary_type);
│ │ │ │ │  eennttrryy (preformatted_type);
│ │ │ │ │  eennttrryy (list_type);
│ │ │ │ │  eennttrryy (span);
│ │ │ │ │ -eennttrryy (dictionary_type);
│ │ │ │ │ +eennttrryy (integer_type);
│ │ │ │ │  constructors directly from a specific type. The content of the argument is
│ │ │ │ │  copied into the newly constructed _e_n_t_r_y
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennttrryy(()) **********
│ │ │ │ │  eennttrryy (data_type t);
│ │ │ │ │  construct an empty _e_n_t_r_y of the specified type. see _d_a_t_a___t_y_p_e enum.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennttrryy(()) **********
│ │ │ │ │  eennttrryy (bdecode_node const& n);
│ │ │ │ │  construct from _b_d_e_c_o_d_e___n_o_d_e parsed form (see _b_d_e_c_o_d_e_(_))
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ooppeerraattoorr==(()) **********
│ │ │ │ │  entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │  entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │  entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │  entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ -entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │  copies the structure of the right hand side into this _e_n_t_r_y.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinntteeggeerr(()) ddiicctt(()) lliisstt(()) pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) **********
│ │ │ │ │ +********** ssttrriinngg(()) iinntteeggeerr(()) lliisstt(()) ddiicctt(()) pprreeffoorrmmaatttteedd(()) **********
│ │ │ │ │  integer_type& iinntteeggeerr ();
│ │ │ │ │ +preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │ +integer_type const& iinntteeggeerr () const;
│ │ │ │ │  list_type& lliisstt ();
│ │ │ │ │ +string_type& ssttrriinngg ();
│ │ │ │ │ +preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │  list_type const& lliisstt () const;
│ │ │ │ │  string_type const& ssttrriinngg () const;
│ │ │ │ │ -dictionary_type const& ddiicctt () const;
│ │ │ │ │ -preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │  dictionary_type& ddiicctt ();
│ │ │ │ │ -preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ -integer_type const& iinntteeggeerr () const;
│ │ │ │ │ -string_type& ssttrriinngg ();
│ │ │ │ │ +dictionary_type const& ddiicctt () const;
│ │ │ │ │  The integer(), string(), list() and dict() functions are accessors that return
│ │ │ │ │  the respective type. If the entry object isn't of the type you request, the
│ │ │ │ │  accessor will throw system_error. You can ask an entry for its type through the
│ │ │ │ │  type() function.
│ │ │ │ │  If you want to create an entry you give it the type you want it to have in its
│ │ │ │ │  constructor, and then use one of the non-const accessors to get a reference
│ │ │ │ │  which you then can assign the value you want it to have.
│ │ │ │ │ @@ -9248,16 +9248,16 @@
│ │ │ │ │  The non-const versions of the operator[] will return a reference to either the
│ │ │ │ │  existing element at the given key or, if there is no element with the given
│ │ │ │ │  key, a reference to a newly inserted element at that key.
│ │ │ │ │  The const version of operator[] will only return a reference to an existing
│ │ │ │ │  element at the given key. If the key is not found, it will throw system_error.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiinndd__kkeeyy(()) **********
│ │ │ │ │ -entry* ffiinndd__kkeeyy (string_view key);
│ │ │ │ │  entry const* ffiinndd__kkeeyy (string_view key) const;
│ │ │ │ │ +entry* ffiinndd__kkeeyy (string_view key);
│ │ │ │ │  These functions requires the _e_n_t_r_y to be a dictionary, if it isn't they will
│ │ │ │ │  throw system_error.
│ │ │ │ │  They will look for an element at the given key in the dictionary, if the
│ │ │ │ │  element cannot be found, they will return nullptr. If an element with the given
│ │ │ │ │  key is found, the return a pointer to it.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoo__ssttrriinngg(()) **********
│ │ │ │ │ @@ -9345,32 +9345,32 @@
│ │ │ │ │     file_storage const& ffiilleess () const;
│ │ │ │ │     void sseett__ccoommmmeenntt (char const* str);
│ │ │ │ │     void sseett__ccrreeaattoorr (char const* str);
│ │ │ │ │     void sseett__ccrreeaattiioonn__ddaattee (std::time_t timestamp);
│ │ │ │ │     void sseett__hhaasshh (piece_index_t index, sha1_hash const& h);
│ │ │ │ │     void sseett__hhaasshh22 (file_index_t file, piece_index_t::diff_type piece,
│ │ │ │ │  sha256_hash const& h);
│ │ │ │ │ -   void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │     void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ +   void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │     void aadddd__nnooddee (std::pair node);
│ │ │ │ │     void aadddd__ttrraacckkeerr (string_view url, int tier = 0);
│ │ │ │ │     void sseett__rroooott__cceerrtt (string_view cert);
│ │ │ │ │     void sseett__pprriivv (bool p);
│ │ │ │ │     bool pprriivv () const;
│ │ │ │ │     bool iiss__vv11__oonnllyy () const;
│ │ │ │ │     bool iiss__vv22__oonnllyy () const;
│ │ │ │ │     int nnuumm__ppiieecceess () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │     file_index_t eenndd__ffiillee () const;
│ │ │ │ │     index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │     index_range ffiillee__ppiieeccee__rraannggee (file_index_t f);
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ -   int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │ +   int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │     void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │  
│ │ │ │ │     static constexpr create_flags_t mmooddiiffiiccaattiioonn__ttiimmee  = 2_bit;
│ │ │ │ │     static constexpr create_flags_t ssyymmlliinnkkss  = 3_bit;
│ │ │ │ │     static constexpr create_flags_t vv22__oonnllyy  = 5_bit;
│ │ │ │ │     static constexpr create_flags_t vv11__oonnllyy  = 6_bit;
│ │ │ │ │ @@ -9398,15 +9398,15 @@
│ │ │ │ │  functions of _c_r_e_a_t_e___t_o_r_r_e_n_t that affects the content of the info dictionary
│ │ │ │ │  (such as _s_e_t___h_a_s_h_(_)), will have any affect. Instead of using this overload,
│ │ │ │ │  consider using _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) instead.
│ │ │ │ │  Warning
│ │ │ │ │  The _f_i_l_e___s_t_o_r_a_g_e and _t_o_r_r_e_n_t___i_n_f_o objects must stay alive for the entire
│ │ │ │ │  duration of the _c_r_e_a_t_e___t_o_r_r_e_n_t object.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeenneerraattee(()) ggeenneerraattee__bbuuff(()) **********
│ │ │ │ │ +********** ggeenneerraattee__bbuuff(()) ggeenneerraattee(()) **********
│ │ │ │ │  entry ggeenneerraattee () const;
│ │ │ │ │  std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │  This function will generate the .torrent file as a bencode tree, or a bencoded
│ │ │ │ │  into a buffer. In order to encode the _e_n_t_r_y into a flat file, use the _b_e_n_c_o_d_e_(_)
│ │ │ │ │  function.
│ │ │ │ │  The function returning an _e_n_t_r_y may be useful to add custom entries to the
│ │ │ │ │  torrent file before bencoding it and saving it to disk.
│ │ │ │ │ @@ -9466,16 +9466,16 @@
│ │ │ │ │  be powers-of-2, so all per-piece merkle trees are complete. A SHA-256 hash of
│ │ │ │ │  all zeros is internally used to indicate a hash that has not been set. Setting
│ │ │ │ │  such hash will not be considered set when calling _g_e_n_e_r_a_t_e_(_). This function
│ │ │ │ │  will throw std::system_error if it is called on an object constructed with the
│ │ │ │ │  v1_only flag.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │  void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ +void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │  This adds a url seed to the torrent. You can have any number of url seeds. For
│ │ │ │ │  a single file torrent, this should be an HTTP url, pointing to a file with
│ │ │ │ │  identical content as the file of the torrent. For a multi-file torrent, it
│ │ │ │ │  should point to a directory containing a directory with the same name as this
│ │ │ │ │  torrent, and all the files of the torrent in it.
│ │ │ │ │  The second function, add_http_seed() adds an HTTP seed instead.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -9502,15 +9502,15 @@
│ │ │ │ │  makes the torrent an SSSSLL ttoorrrreenntt. An SSL torrent requires that each peer has a
│ │ │ │ │  valid certificate signed by this root certificate. For SSL torrents, all peers
│ │ │ │ │  are connecting over SSL connections. For more information, see the section on
│ │ │ │ │  _s_s_l_ _t_o_r_r_e_n_t_s.
│ │ │ │ │  The string is not the path to the cert, it's the actual content of the
│ │ │ │ │  certificate.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** pprriivv(()) sseett__pprriivv(()) **********
│ │ │ │ │ +********** sseett__pprriivv(()) pprriivv(()) **********
│ │ │ │ │  void sseett__pprriivv (bool p);
│ │ │ │ │  bool pprriivv () const;
│ │ │ │ │  Sets and queries the private flag of the torrent. Torrents with the private
│ │ │ │ │  flag set ask the client to not use any other sources than the tracker for
│ │ │ │ │  peers, and to not use DHT to advertise itself publicly, only the tracker.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnuumm__ppiieecceess(()) **********
│ │ │ │ │ @@ -9530,17 +9530,17 @@
│ │ │ │ │  for v2 and hybrid torrents only, the pieces in the specified file, specified as
│ │ │ │ │  delta from the first piece in the file. i.e. the first index is 0.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │  std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │  the total number of bytes of all files and pad files
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__lleennggtthh(()) ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** ppiieeccee__ssiizzee(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │  int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │ +int ppiieeccee__lleennggtthh () const;
│ │ │ │ │  piece_length() returns the piece size of all pieces but the last one.
│ │ │ │ │  piece_size() returns the size of the specified piece. these functions are just
│ │ │ │ │  forwarding to the associated _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) **********
│ │ │ │ │  void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │  void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │ @@ -9615,30 +9615,30 @@
│ │ │ │ │  directories are traversed.
│ │ │ │ │  The ".." directory is never traversed.
│ │ │ │ │  The flags argument should be the same as the flags passed to the _c_r_e_a_t_e___t_o_r_r_e_n_t
│ │ │ │ │  constructor.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ sseett__ppiieeccee__hhaasshheess(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_r_e_a_t_e___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ -void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , std::function const& f, error_code& ec);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │  void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │     , settings_interface const& settings
│ │ │ │ │     , std::function const& f, error_code& ec);
│ │ │ │ │  void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ │     , std::function const& f, error_code& ec);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p,
│ │ │ │ │ -error_code& ec);
│ │ │ │ │  inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , settings_interface const& settings
│ │ │ │ │     , std::function const& f);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │  inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ +   , settings_interface const& settings
│ │ │ │ │     , std::function const& f);
│ │ │ │ │ +void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ +   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ │ +   , std::function const& f, error_code& ec);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p,
│ │ │ │ │ +error_code& ec);
│ │ │ │ │  This function will assume that the files added to the torrent file exists at
│ │ │ │ │  path p, read those files and hash the content and set the hashes in the
│ │ │ │ │  create_torrent object. The optional function f is called in between every hash
│ │ │ │ │  that is set. f must have the following signature:
│ │ │ │ │  void Fun(piece_index_t);
│ │ │ │ │  The overloads taking a _s_e_t_t_i_n_g_s___p_a_c_k may be used to configure the underlying
│ │ │ │ │  disk access. Such as settings_pack::aio_threads.
│ │ │ │ │ @@ -9648,67 +9648,67 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ bbiittffiieelldd ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_i_t_f_i_e_l_d_._h_p_p"
│ │ │ │ │  The _b_i_t_f_i_e_l_d type stores any number of bits as a _b_i_t_f_i_e_l_d in a heap allocated
│ │ │ │ │  array.
│ │ │ │ │  struct bitfield
│ │ │ │ │  {
│ │ │ │ │ +   bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +   bbiittffiieelldd (int bits, bool val);
│ │ │ │ │     bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ -   bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │     explicit bbiittffiieelldd (int bits);
│ │ │ │ │     bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -   bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ -   bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +   bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │     void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │ -   bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │     bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ -   void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +   bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │     void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +   void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │     bool aallll__sseett () const noexcept;
│ │ │ │ │     bool nnoonnee__sseett () const noexcept;
│ │ │ │ │     int ssiizzee () const noexcept;
│ │ │ │ │     int nnuumm__wwoorrddss () const noexcept;
│ │ │ │ │     int nnuumm__bbyytteess () const noexcept;
│ │ │ │ │     bool eemmppttyy () const noexcept;
│ │ │ │ │ -   char* ddaattaa () noexcept;
│ │ │ │ │     char const* ddaattaa () const noexcept;
│ │ │ │ │ +   char* ddaattaa () noexcept;
│ │ │ │ │     void sswwaapp (bitfield& rhs) noexcept;
│ │ │ │ │     int ccoouunntt () const noexcept;
│ │ │ │ │     int ffiinndd__ffiirrsstt__sseett () const noexcept;
│ │ │ │ │     int ffiinndd__llaasstt__cclleeaarr () const noexcept;
│ │ │ │ │     bool ooppeerraattoorr==== (lt::bitfield const& rhs) const;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bbiittffiieelldd(()) **********
│ │ │ │ │ +bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (int bits, bool val);
│ │ │ │ │  bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ -bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │  explicit bbiittffiieelldd (int bits);
│ │ │ │ │  bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ -bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │  constructs a new _b_i_t_f_i_e_l_d. The default constructor creates an empty _b_i_t_f_i_e_l_d.
│ │ │ │ │  bits is the size of the _b_i_t_f_i_e_l_d (specified in bits). val is the value to
│ │ │ │ │  initialize the bits to. If not specified all bits are initialized to 0.
│ │ │ │ │  The constructor taking a pointer b and bits copies a _b_i_t_f_i_e_l_d from the
│ │ │ │ │  specified buffer, and bits number of bits (rounded up to the nearest byte
│ │ │ │ │  boundary).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aassssiiggnn(()) **********
│ │ │ │ │  void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │  copy _b_i_t_f_i_e_l_d from buffer b of bits number of bits, rounded up to the nearest
│ │ │ │ │  byte boundary.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ooppeerraattoorr[[]](()) ggeett__bbiitt(()) **********
│ │ │ │ │ -bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │  bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ +bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │  query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__bbiitt(()) cclleeaarr__bbiitt(()) **********
│ │ │ │ │ -void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +********** cclleeaarr__bbiitt(()) sseett__bbiitt(()) **********
│ │ │ │ │  void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │  set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aallll__sseett(()) **********
│ │ │ │ │  bool aallll__sseett () const noexcept;
│ │ │ │ │  returns true if all bits in the _b_i_t_f_i_e_l_d are set
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnoonnee__sseett(()) **********
│ │ │ │ │ @@ -9729,16 +9729,16 @@
│ │ │ │ │  returns the number of bytes needed to represent all bits in this _b_i_t_f_i_e_l_d
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eemmppttyy(()) **********
│ │ │ │ │  bool eemmppttyy () const noexcept;
│ │ │ │ │  returns true if the _b_i_t_f_i_e_l_d has zero size.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ddaattaa(()) **********
│ │ │ │ │ -char* ddaattaa () noexcept;
│ │ │ │ │  char const* ddaattaa () const noexcept;
│ │ │ │ │ +char* ddaattaa () noexcept;
│ │ │ │ │  returns a pointer to the internal buffer of the _b_i_t_f_i_e_l_d, or nullptr if it's
│ │ │ │ │  empty.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sswwaapp(()) **********
│ │ │ │ │  void sswwaapp (bitfield& rhs) noexcept;
│ │ │ │ │  swaps the bit-fields two variables refer to
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -9767,29 +9767,29 @@
│ │ │ │ │  If you want to reuse the _h_a_s_h_e_r object once you have created a hash, you have
│ │ │ │ │  to call reset() to reinitialize it.
│ │ │ │ │  The built-in software version of sha1-algorithm was implemented by Steve Reid
│ │ │ │ │  and released as public domain. For more info, see src/sha1.cpp.
│ │ │ │ │  class hasher
│ │ │ │ │  {
│ │ │ │ │     hhaasshheerr ();
│ │ │ │ │ -   explicit hhaasshheerr (span data);
│ │ │ │ │ +   hhaasshheerr (hasher const&);
│ │ │ │ │     hhaasshheerr (char const* data, int len);
│ │ │ │ │ +   explicit hhaasshheerr (span data);
│ │ │ │ │     hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ -   hhaasshheerr (hasher const&);
│ │ │ │ │     hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │     hasher& uuppddaattee (span data);
│ │ │ │ │     sha1_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ooppeerraattoorr==(()) hhaasshheerr(()) **********
│ │ │ │ │ -explicit hhaasshheerr (span data);
│ │ │ │ │ +hhaasshheerr (hasher const&);
│ │ │ │ │  hhaasshheerr (char const* data, int len);
│ │ │ │ │ +explicit hhaasshheerr (span data);
│ │ │ │ │  hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ -hhaasshheerr (hasher const&);
│ │ │ │ │  this is the same as default constructing followed by a call to update(data,
│ │ │ │ │  len).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** uuppddaattee(()) **********
│ │ │ │ │  hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │  hasher& uuppddaattee (span data);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ │ │ @@ -9805,36 +9805,36 @@
│ │ │ │ │  constructed.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ hhaasshheerr225566 ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_h_a_s_h_e_r_._h_p_p"
│ │ │ │ │  class hasher256
│ │ │ │ │  {
│ │ │ │ │     hhaasshheerr225566 ();
│ │ │ │ │ -   hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │     explicit hhaasshheerr225566 (span data);
│ │ │ │ │ -   hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │     hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ -   hasher256& uuppddaattee (span data);
│ │ │ │ │ +   hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +   hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │     hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ +   hasher256& uuppddaattee (span data);
│ │ │ │ │     sha256_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │     ~~hhaasshheerr225566 ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshheerr225566(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ +********** ooppeerraattoorr==(()) hhaasshheerr225566(()) **********
│ │ │ │ │  explicit hhaasshheerr225566 (span data);
│ │ │ │ │ -hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │  hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │  this is the same as default constructing followed by a call to update(data,
│ │ │ │ │  len).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher256& uuppddaattee (span data);
│ │ │ │ │  hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ +hasher256& uuppddaattee (span data);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiinnaall(()) **********
│ │ │ │ │  sha256_hash ffiinnaall ();
│ │ │ │ │  returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │  _h_a_s_h_e_r constructor.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -10391,19 +10391,19 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ aannnnoouunnccee__eennttrryy ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │  this class holds information about one bittorrent tracker, as it relates to a
│ │ │ │ │  specific torrent.
│ │ │ │ │  struct announce_entry
│ │ │ │ │  {
│ │ │ │ │ -   ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -   explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │     aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │     announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │     aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +   explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +   ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │  
│ │ │ │ │     enum tracker_source
│ │ │ │ │     {
│ │ │ │ │        source_torrent,
│ │ │ │ │        source_client,
│ │ │ │ │        source_magnet_link,
│ │ │ │ │        source_tex,
│ │ │ │ │ @@ -10415,19 +10415,19 @@
│ │ │ │ │     std::uint8_t ttiieerr  = 0;
│ │ │ │ │     std::uint8_t ffaaiill__lliimmiitt  = 0;
│ │ │ │ │     std::uint8_t source:4;
│ │ │ │ │     bool verified:1;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) ~~aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │ -~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │  aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │  announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │  aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │  constructs a tracker announce _e_n_t_r_y with u as the URL.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennuumm ttrraacckkeerr__ssoouurrccee **********
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │   _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
│ │ │ │ │  |_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │  |_s_o_u_r_c_e___t_o_r_r_e_n_t_ _ _ _ _|_1_ _ _ _ _|_t_h_e_ _t_r_a_c_k_e_r_ _w_a_s_ _p_a_r_t_ _o_f_ _t_h_e_ _._t_o_r_r_e_n_t_ _f_i_l_e_ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ @@ -11872,24 +11872,24 @@
│ │ │ │ │  connect to the external NAT-PMP port (configured using announce_port) instead
│ │ │ │ │  of the actual local listening port.
│ │ │ │ │  struct settings_pack final : settings_interface
│ │ │ │ │  {
│ │ │ │ │     friend  void aappppllyy__ppaacckk__iimmppll (settings_pack const*
│ │ │ │ │        , aux::session_settings_single_thread&
│ │ │ │ │        , std::vector*);
│ │ │ │ │ -   void sseett__iinntt (int name, int val) override;
│ │ │ │ │ -   void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ -   void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │     void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ +   void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │ +   void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ +   void sseett__iinntt (int name, int val) override;
│ │ │ │ │     bool hhaass__vvaall (int name) const override;
│ │ │ │ │     void cclleeaarr ();
│ │ │ │ │     void cclleeaarr (int name);
│ │ │ │ │ -   std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │     bool ggeett__bbooooll (int name) const override;
│ │ │ │ │     int ggeett__iinntt (int name) const override;
│ │ │ │ │ +   std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │     void ffoorr__eeaacchh (Fun&& f) const;
│ │ │ │ │  
│ │ │ │ │     enum type_bases
│ │ │ │ │     {
│ │ │ │ │        string_type_base,
│ │ │ │ │        int_type_base,
│ │ │ │ │        bool_type_base,
│ │ │ │ │ @@ -11959,19 +11959,19 @@
│ │ │ │ │        socks5,
│ │ │ │ │        socks5_pw,
│ │ │ │ │        http,
│ │ │ │ │        http_pw,
│ │ │ │ │     };
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__bbooooll(()) sseett__ssttrr(()) sseett__iinntt(()) **********
│ │ │ │ │ -void sseett__iinntt (int name, int val) override;
│ │ │ │ │ -void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ -void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │ +********** sseett__ssttrr(()) sseett__bbooooll(()) sseett__iinntt(()) **********
│ │ │ │ │  void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ +void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │ +void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ +void sseett__iinntt (int name, int val) override;
│ │ │ │ │  set a configuration option in the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of the enum values
│ │ │ │ │  from string_types, int_types or bool_types. They must match the respective type
│ │ │ │ │  of the set_* function.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** hhaass__vvaall(()) **********
│ │ │ │ │  bool hhaass__vvaall (int name) const override;
│ │ │ │ │  queries whether the specified configuration option has a value set in this
│ │ │ │ │ @@ -11982,18 +11982,18 @@
│ │ │ │ │  void cclleeaarr ();
│ │ │ │ │  clear the settings pack from all settings
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr(()) **********
│ │ │ │ │  void cclleeaarr (int name);
│ │ │ │ │  clear a specific setting from the pack
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__bbooooll(()) ggeett__iinntt(()) ggeett__ssttrr(()) **********
│ │ │ │ │ -std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │ +********** ggeett__ssttrr(()) ggeett__iinntt(()) ggeett__bbooooll(()) **********
│ │ │ │ │  bool ggeett__bbooooll (int name) const override;
│ │ │ │ │  int ggeett__iinntt (int name) const override;
│ │ │ │ │ +std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │  queries the current configuration option from the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of
│ │ │ │ │  the enumeration values from string_types, int_types or bool_types. The enum
│ │ │ │ │  value must match the type of the get_* function. If the specified setting field
│ │ │ │ │  has not been set, the default value is returned.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** eennuumm ttyyppee__bbaasseess **********
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │ @@ -12171,16 +12171,16 @@
│ │ │ │ │  high_performance_seed returns settings optimized for a seed box, serving many
│ │ │ │ │  peers and that doesn't do any downloading. It has a 128 MB disk cache and has a
│ │ │ │ │  limit of 400 files in its file pool. It support fast upload rates by allowing
│ │ │ │ │  large send buffers.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ sseettttiinngg__bbyy__nnaammee(()) nnaammee__ffoorr__sseettttiinngg(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │ -int sseettttiinngg__bbyy__nnaammee (string_view name);
│ │ │ │ │  char const* nnaammee__ffoorr__sseettttiinngg (int s);
│ │ │ │ │ +int sseettttiinngg__bbyy__nnaammee (string_view name);
│ │ │ │ │  converts a setting integer (from the enums string_types, int_types or
│ │ │ │ │  bool_types) to a string, and vice versa.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ddeeffaauulltt__sseettttiinnggss(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │  settings_pack ddeeffaauulltt__sseettttiinnggss ();
│ │ │ │ │  returns a _s_e_t_t_i_n_g_s___p_a_c_k with every setting set to its default value
│ │ │ │ │ @@ -12190,45 +12190,45 @@
│ │ │ │ │  Sometimes it's important to get a non-owning reference to the root node ( to be
│ │ │ │ │  able to copy it as a reference for instance). For that, use the _n_o_n___o_w_n_i_n_g_(_)
│ │ │ │ │  member function.
│ │ │ │ │  There are 5 different types of nodes, see _t_y_p_e___t.
│ │ │ │ │  struct bdecode_node
│ │ │ │ │  {
│ │ │ │ │     bbddeeccooddee__nnooddee () = default;
│ │ │ │ │ -   bbddeeccooddee__nnooddee (bdecode_node const&);
│ │ │ │ │     bdecode_node& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │     bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │     bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default;
│ │ │ │ │ +   bbddeeccooddee__nnooddee (bdecode_node const&);
│ │ │ │ │     type_t ttyyppee () const noexcept;
│ │ │ │ │     explicit operator bbooooll () const noexcept;
│ │ │ │ │     bdecode_node nnoonn__oowwnniinngg () const;
│ │ │ │ │     span ddaattaa__sseeccttiioonn () const noexcept;
│ │ │ │ │     std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept;
│ │ │ │ │ -   int lliisstt__ssiizzee () const;
│ │ │ │ │ -   string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │ -      , string_view default_val = string_view()) const;
│ │ │ │ │ -   bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │     std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ │ +   bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │ +   string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │ +      , string_view default_val = string_view()) const;
│ │ │ │ │ +   int lliisstt__ssiizzee () const;
│ │ │ │ │     int ddiicctt__ssiizzee () const;
│ │ │ │ │ -   std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ +   std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ +      , std::int64_t default_val = 0) const;
│ │ │ │ │ +   bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │     std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ +   std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │     bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │ +   bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │     bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ -   std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ -      , std::int64_t default_val = 0) const;
│ │ │ │ │     string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key
│ │ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │ │     bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │     std::int64_t iinntt__vvaalluuee () const;
│ │ │ │ │ -   char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │ -   std::ptrdiff_t ssttrriinngg__ooffffsseett () const;
│ │ │ │ │     int ssttrriinngg__lleennggtthh () const;
│ │ │ │ │ +   std::ptrdiff_t ssttrriinngg__ooffffsseett () const;
│ │ │ │ │ +   char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │     string_view ssttrriinngg__vvaalluuee () const;
│ │ │ │ │     void cclleeaarr ();
│ │ │ │ │     void sswwaapp (bdecode_node& n);
│ │ │ │ │     void rreesseerrvvee (int tokens);
│ │ │ │ │     void sswwiittcchh__uunnddeerrllyyiinngg__bbuuffffeerr (char const* buf) noexcept;
│ │ │ │ │     bool hhaass__ssoofftt__eerrrroorr (span error) const;
│ │ │ │ │  
│ │ │ │ │ @@ -12243,18 +12243,18 @@
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bbddeeccooddee__nnooddee(()) **********
│ │ │ │ │  bbddeeccooddee__nnooddee () = default;
│ │ │ │ │  creates a default constructed node, it will have the type none_t.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** bbddeeccooddee__nnooddee(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -bbddeeccooddee__nnooddee (bdecode_node const&);
│ │ │ │ │  bdecode_node& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │  bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │  bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default;
│ │ │ │ │ +bbddeeccooddee__nnooddee (bdecode_node const&);
│ │ │ │ │  For owning nodes, the copy will create a copy of the tree, but the underlying
│ │ │ │ │  buffer remains the same.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttyyppee(()) **********
│ │ │ │ │  type_t ttyyppee () const noexcept;
│ │ │ │ │  the type of this node. See _t_y_p_e___t.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -12263,47 +12263,47 @@
│ │ │ │ │  returns true if _t_y_p_e_(_) != none_t.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** nnoonn__oowwnniinngg(()) **********
│ │ │ │ │  bdecode_node nnoonn__oowwnniinngg () const;
│ │ │ │ │  return a non-owning reference to this node. This is useful to refer to the root
│ │ │ │ │  node without copying it in assignments.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddaattaa__sseeccttiioonn(()) ddaattaa__ooffffsseett(()) **********
│ │ │ │ │ +********** ddaattaa__ooffffsseett(()) ddaattaa__sseeccttiioonn(()) **********
│ │ │ │ │  span ddaattaa__sseeccttiioonn () const noexcept;
│ │ │ │ │  std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept;
│ │ │ │ │  returns the buffer and length of the section in the original bencoded buffer
│ │ │ │ │  where this node is defined. For a dictionary for instance, this starts with d
│ │ │ │ │  and ends with e, and has all the content of the dictionary in between. the
│ │ │ │ │  data_offset() function returns the byte-offset to this node in, starting from
│ │ │ │ │  the beginning of the buffer that was parsed.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** lliisstt__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__iinntt__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) **********
│ │ │ │ │ -int lliisstt__ssiizzee () const;
│ │ │ │ │ -string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │ -      , string_view default_val = string_view()) const;
│ │ │ │ │ -bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │ +********** lliisstt__iinntt__vvaalluuee__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__aatt(()) **********
│ │ │ │ │  std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ │ +bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │ +string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │ +      , string_view default_val = string_view()) const;
│ │ │ │ │ +int lliisstt__ssiizzee () const;
│ │ │ │ │  functions with the list_ prefix operate on lists. These functions are only
│ │ │ │ │  valid if type() == list_t. list_at() returns the item in the list at index i. i
│ │ │ │ │  may not be greater than or equal to the size of the list. size() returns the
│ │ │ │ │  size of the list.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddiicctt__aatt(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ssiizzee(()) ddiicctt__ffiinndd__iinntt(())
│ │ │ │ │ -ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd(()) ddiicctt__aatt__nnooddee(()) ddiicctt__ffiinndd__ssttrriinngg(())
│ │ │ │ │ -ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd__lliisstt(()) **********
│ │ │ │ │ +********** ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__aatt__nnooddee(()) ddiicctt__ffiinndd(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__ssttrriinngg(())
│ │ │ │ │ +ddiicctt__ffiinndd__lliisstt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(())
│ │ │ │ │ +ddiicctt__ssiizzee(()) **********
│ │ │ │ │  int ddiicctt__ssiizzee () const;
│ │ │ │ │ -std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ +std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ +      , std::int64_t default_val = 0) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │  std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ +std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │  bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │  bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ -std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ -      , std::int64_t default_val = 0) const;
│ │ │ │ │  string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key
│ │ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │ │  bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │  Functions with the dict_ prefix operates on dictionaries. They are only valid
│ │ │ │ │  if type() == dict_t. In case a key you're looking up contains a 0 byte, you
│ │ │ │ │  cannot use the 0-terminated string overloads, but have to use string_view
│ │ │ │ │  instead. dict_find_list will return a valid bdecode_node if the key is found
│ │ │ │ │ @@ -12318,18 +12318,18 @@
│ │ │ │ │  string).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iinntt__vvaalluuee(()) **********
│ │ │ │ │  std::int64_t iinntt__vvaalluuee () const;
│ │ │ │ │  this function is only valid if type() == int_t. It returns the value of the
│ │ │ │ │  integer.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssttrriinngg__lleennggtthh(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__ooffffsseett(()) ssttrriinngg__ppttrr(()) **********
│ │ │ │ │ -char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │ -std::ptrdiff_t ssttrriinngg__ooffffsseett () const;
│ │ │ │ │ +********** ssttrriinngg__ooffffsseett(()) ssttrriinngg__ppttrr(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__vvaalluuee(()) **********
│ │ │ │ │  int ssttrriinngg__lleennggtthh () const;
│ │ │ │ │ +std::ptrdiff_t ssttrriinngg__ooffffsseett () const;
│ │ │ │ │ +char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │  string_view ssttrriinngg__vvaalluuee () const;
│ │ │ │ │  these functions are only valid if type() == string_t. They return the string
│ │ │ │ │  values. Note that string_ptr() is nnoott 0-terminated. string_length() returns the
│ │ │ │ │  number of bytes in the string. string_offset() returns the byte offset from the
│ │ │ │ │  start of the parsed bencoded buffer this string can be found.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr(()) **********
│ │ │ │ │ @@ -12633,21 +12633,21 @@
│ │ │ │ │        when using uTP.
│ │ │ │ │    ssl_torrent
│ │ │ │ │        Specify the port number for the SSL listen socket in the DHT announce.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ rreeaadd__rreessuummee__ddaattaa(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_r_e_a_d___r_e_s_u_m_e___d_a_t_a_._h_p_p"
│ │ │ │ │  add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ +   , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ │ +add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │     , load_torrent_limits const& cfg = {});
│ │ │ │ │  add_torrent_params rreeaadd__rreessuummee__ddaattaa (bdecode_node const& rd
│ │ │ │ │     , int piece_limit = 0x200000);
│ │ │ │ │  add_torrent_params rreeaadd__rreessuummee__ddaattaa (bdecode_node const& rd
│ │ │ │ │     , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ │ -add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ -   , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ │  these functions are used to parse resume data and populate the appropriate
│ │ │ │ │  fields in an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object. This object can then be used to add the
│ │ │ │ │  actual _t_o_r_r_e_n_t___i_n_f_o object to and pass to session::add_torrent() or session::
│ │ │ │ │  async_add_torrent().
│ │ │ │ │  If the client wants to override any field that was loaded from the resume data,
│ │ │ │ │  e.g. save_path, those fields must be changed after loading resume data but
│ │ │ │ │  before adding the torrent.
│ │ │ │ │ @@ -12655,28 +12655,28 @@
│ │ │ │ │  the torrent that may be loaded as part of the resume data, if it contains an
│ │ │ │ │  info field. The overloads that take a flat buffer are instead configured with
│ │ │ │ │  limits on torrent sizes via load_torrent limits.
│ │ │ │ │  In order to support large torrents, it may also be necessary to raise the
│ │ │ │ │  _s_e_t_t_i_n_g_s___p_a_c_k_:_:_m_a_x___p_i_e_c_e___c_o_u_n_t setting and pass a higher limit to calls to
│ │ │ │ │  _t_o_r_r_e_n_t___i_n_f_o_:_:_p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ wwrriittee__rreessuummee__ddaattaa(()) wwrriittee__rreessuummee__ddaattaa__bbuuff(()) ************
│ │ │ │ │ +************ wwrriittee__rreessuummee__ddaattaa__bbuuff(()) wwrriittee__rreessuummee__ddaattaa(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_._h_p_p"
│ │ │ │ │ -entry wwrriittee__rreessuummee__ddaattaa (add_torrent_params const& atp);
│ │ │ │ │  std::vector wwrriittee__rreessuummee__ddaattaa__bbuuff (add_torrent_params const& atp);
│ │ │ │ │ +entry wwrriittee__rreessuummee__ddaattaa (add_torrent_params const& atp);
│ │ │ │ │  this function turns the resume data in an add_torrent_params object into a
│ │ │ │ │  bencoded structure
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ wwrriittee__ttoorrrreenntt__ffiillee__bbuuff(()) wwrriittee__ttoorrrreenntt__ffiillee(()) ************
│ │ │ │ │ +************ wwrriittee__ttoorrrreenntt__ffiillee(()) wwrriittee__ttoorrrreenntt__ffiillee__bbuuff(()) ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_._h_p_p"
│ │ │ │ │ -entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp);
│ │ │ │ │  std::vector wwrriittee__ttoorrrreenntt__ffiillee__bbuuff (add_torrent_params const& atp
│ │ │ │ │     , write_torrent_flags_t flags);
│ │ │ │ │  entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp, write_torrent_flags_t
│ │ │ │ │  flags);
│ │ │ │ │ +entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp);
│ │ │ │ │  writes only the fields to create a .torrent file. This function may fail with a
│ │ │ │ │  std::system_error exception if:
│ │ │ │ │      * The _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object passed to this function does not contain
│ │ │ │ │        the info dictionary (the ti field)
│ │ │ │ │      * The piece layers are not complete for all files that need them
│ │ │ │ │  The write_torrent_file_buf() overload returns the torrent file in bencoded
│ │ │ │ │  buffer form. This overload may be faster at the expense of lost flexibility to